Changeset 1389


Ignore:
Timestamp:
08/30/06 17:04:51 (14 years ago)
Author:
curtis
Message:

Clean up style issues in Bio-Formats.

Location:
trunk
Files:
40 edited

Legend:

Unmodified
Added
Removed
  • trunk/checkstyle.xml

    r1388 r1389  
    122122    <module name="HiddenField"> 
    123123      <property name="ignoreConstructorParameter" value="true"/> 
     124      <property name="ignoreSetter" value="true"/> 
    124125    </module> 
    125126    <module name="IllegalInstantiation"/> 
    126127<!--    <module name="InnerAssignment"/> --> 
    127128<!--        <module name="MagicNumber"/> --> 
    128     <module name="MissingSwitchDefault"/> 
     129<!--    <module name="MissingSwitchDefault"/> --> 
    129130    <module name="RedundantThrows"/> 
    130131    <module name="SimplifyBooleanExpression"/> 
     
    149150      <property name="message" value="Line has trailing spaces."/> 
    150151    </module> 
     152<!-- 
     153    <module name="Indentation"> 
     154      <property name="basicOffset" value="2"/> 
     155      <property name="caseIndent" value="2"/> 
     156    </module> 
     157--> 
    151158    <module name="TodoComment"> 
    152159      <property name="format" value="TODO"/> 
  • trunk/loci/apps/slim/SlimPlotter.java

    r1388 r1389  
    3737  /** Default orientation for decay curves display. */ 
    3838  private static final double[] MATRIX = { 
    39      0.2821, 0.1503, -0.0201, 0.0418, 
    40     -0.0500,  0.1323, 0.2871, 0.1198, 
    41      0.1430, -0.2501, 0.1408, 0.0089, 
    42      0.0000,  0.0000, 0.0000, 1.0000 
     39    0.2821, 0.1503, -0.0201, 0.0418, 
     40    -0.0500, 0.1323, 0.2871, 0.1198, 
     41    0.1430, -0.2501, 0.1408, 0.0089, 
     42    0.0000, 0.0000, 0.0000, 1.0000 
    4343  }; 
    4444 
  • trunk/loci/formats/in/AVIReader.java

    r1264 r1389  
    5252  private boolean little = true; 
    5353 
    54   String type = "error"; 
    55   String fcc = "error"; 
    56   int size = -1; 
    57   int bigChunkSize; 
    58   long pos; 
     54  private String type = "error"; 
     55  private String fcc = "error"; 
     56  private int size = -1; 
     57  private int bigChunkSize; 
     58  private long pos; 
    5959 
    6060  // AVI Header chunk fields 
    6161 
    62   int dwMicroSecPerFrame, dwMaxBytesPerSec, dwReserved1, dwFlags, 
     62  private int dwMicroSecPerFrame, dwMaxBytesPerSec, dwReserved1, dwFlags, 
    6363    dwTotalFrames, dwInitialFrames, dwStreams, dwSuggestedBufferSize, dwWidth, 
    6464    dwHeight, dwScale, dwRate, dwStart, dwLength; 
     
    6666  // Stream Header chunk fields 
    6767 
    68   String fccStreamType, fccStreamHandler; 
    69   int dwStreamFlags, dwStreamReserved1, dwStreamInitialFrames, dwStreamScale, 
    70     dwStreamRate, dwStreamStart, dwStreamLength, dwStreamSuggestedBufferSize, 
    71     dwStreamQuality, dwStreamSampleSize; 
     68  private String fccStreamType, fccStreamHandler; 
     69  private int dwStreamFlags, dwStreamReserved1, dwStreamInitialFrames, 
     70    dwStreamScale, dwStreamRate, dwStreamStart, dwStreamLength, 
     71    dwStreamSuggestedBufferSize, dwStreamQuality, dwStreamSampleSize; 
    7272 
    7373  // Stream Format chunk fields 
    7474 
    75   int bmpSize, bmpSizeOfBitmap, bmpHorzResolution, bmpVertResolution, 
     75  private int bmpSize, bmpSizeOfBitmap, bmpHorzResolution, bmpVertResolution, 
    7676    bmpColorsUsed, bmpColorsImportant, bmpNoOfPixels, bmpWidth, bmpHeight, 
    7777    bmpCompression, bmpActualSize, bmpScanLineSize, bmpActualColorsUsed; 
    78   short bmpPlanes, bmpBitsPerPixel; 
    79   boolean bmpTopDown; 
    80   byte[] rawData = null; 
    81   byte[] pr = null; 
    82   byte[] pg = null; 
    83   byte[] pb = null; 
    84  
     78  private short bmpPlanes, bmpBitsPerPixel; 
     79  private boolean bmpTopDown; 
     80  private byte[] rawData = null; 
     81  private byte[] pr = null; 
     82  private byte[] pg = null; 
     83  private byte[] pb = null; 
    8584 
    8685  // -- Constructor -- 
     
    8887  /** Constructs a new AVI reader. */ 
    8988  public AVIReader() { super("Audio Video Interleave", "avi"); } 
    90  
    9189 
    9290  // -- FormatReader API methods -- 
     
    596594  } 
    597595 
    598  
    599596  // -- Main method -- 
    600597 
  • trunk/loci/formats/in/AndorReader.java

    r1264 r1389  
    314314        // find the minimum non-zero difference 
    315315        float difference = ((Float) diff.get(i)).floatValue(); 
    316         if (difference != 0 && difference < min && added[i] == false) { 
     316        if (difference != 0 && difference < min && !added[i]) { 
    317317          min = difference; 
    318318          index = i; 
  • trunk/loci/formats/in/BMPReader.java

    r1335 r1389  
    6363  /** 
    6464   * Compression type: 
    65    * 0 = no compression 
    66    * 1 = 8 bit run length encoding 
    67    * 2 = 4 bit run length encoding 
    68    * 3 = RGB bitmap with mask 
     65   * 0 = no compression, 
     66   * 1 = 8 bit run length encoding, 
     67   * 2 = 4 bit run length encoding, 
     68   * 3 = RGB bitmap with mask. 
    6969   */ 
    7070  protected int compression; 
  • trunk/loci/formats/in/BZip2Constants.java

    r1264 r1389  
    5151 * Base class for both the compress and decompress classes. 
    5252 * Holds common arrays, and static data. 
    53  * 
    5453 */ 
    5554public interface BZip2Constants { 
    5655 
    57     int BASE_BLOCK_SIZE = 100000; 
    58     int MAX_ALPHA_SIZE = 258; 
    59     int MAX_CODE_LEN = 23; 
    60     int RUNA = 0; 
    61     int RUNB = 1; 
    62     int N_GROUPS = 6; 
    63     int G_SIZE = 50; 
    64     int N_ITERS = 4; 
    65     int MAX_SELECTORS = (2 + (900000 / G_SIZE)); 
    66     int NUM_OVERSHOOT_BYTES = 20; 
     56  int BASE_BLOCK_SIZE = 100000; 
     57  int MAX_ALPHA_SIZE = 258; 
     58  int MAX_CODE_LEN = 23; 
     59  int RUNA = 0; 
     60  int RUNB = 1; 
     61  int N_GROUPS = 6; 
     62  int G_SIZE = 50; 
     63  int N_ITERS = 4; 
     64  int MAX_SELECTORS = (2 + (900000 / G_SIZE)); 
     65  int NUM_OVERSHOOT_BYTES = 20; 
    6766 
    68     int[] R_NUMS = { 
    69         619, 720, 127, 481, 931, 816, 813, 233, 566, 247, 
    70         985, 724, 205, 454, 863, 491, 741, 242, 949, 214, 
    71         733, 859, 335, 708, 621, 574, 73, 654, 730, 472, 
    72         419, 436, 278, 496, 867, 210, 399, 680, 480, 51, 
    73         878, 465, 811, 169, 869, 675, 611, 697, 867, 561, 
    74         862, 687, 507, 283, 482, 129, 807, 591, 733, 623, 
    75         150, 238, 59, 379, 684, 877, 625, 169, 643, 105, 
    76         170, 607, 520, 932, 727, 476, 693, 425, 174, 647, 
    77         73, 122, 335, 530, 442, 853, 695, 249, 445, 515, 
    78         909, 545, 703, 919, 874, 474, 882, 500, 594, 612, 
    79         641, 801, 220, 162, 819, 984, 589, 513, 495, 799, 
    80         161, 604, 958, 533, 221, 400, 386, 867, 600, 782, 
    81         382, 596, 414, 171, 516, 375, 682, 485, 911, 276, 
    82         98, 553, 163, 354, 666, 933, 424, 341, 533, 870, 
    83         227, 730, 475, 186, 263, 647, 537, 686, 600, 224, 
    84         469, 68, 770, 919, 190, 373, 294, 822, 808, 206, 
    85         184, 943, 795, 384, 383, 461, 404, 758, 839, 887, 
    86         715, 67, 618, 276, 204, 918, 873, 777, 604, 560, 
    87         951, 160, 578, 722, 79, 804, 96, 409, 713, 940, 
    88         652, 934, 970, 447, 318, 353, 859, 672, 112, 785, 
    89         645, 863, 803, 350, 139, 93, 354, 99, 820, 908, 
    90         609, 772, 154, 274, 580, 184, 79, 626, 630, 742, 
    91         653, 282, 762, 623, 680, 81, 927, 626, 789, 125, 
    92         411, 521, 938, 300, 821, 78, 343, 175, 128, 250, 
    93         170, 774, 972, 275, 999, 639, 495, 78, 352, 126, 
    94         857, 956, 358, 619, 580, 124, 737, 594, 701, 612, 
    95         669, 112, 134, 694, 363, 992, 809, 743, 168, 974, 
    96         944, 375, 748, 52, 600, 747, 642, 182, 862, 81, 
    97         344, 805, 988, 739, 511, 655, 814, 334, 249, 515, 
    98         897, 955, 664, 981, 649, 113, 974, 459, 893, 228, 
    99         433, 837, 553, 268, 926, 240, 102, 654, 459, 51, 
    100         686, 754, 806, 760, 493, 403, 415, 394, 687, 700, 
    101         946, 670, 656, 610, 738, 392, 760, 799, 887, 653, 
    102         978, 321, 576, 617, 626, 502, 894, 679, 243, 440, 
    103         680, 879, 194, 572, 640, 724, 926, 56, 204, 700, 
    104         707, 151, 457, 449, 797, 195, 791, 558, 945, 679, 
    105         297, 59, 87, 824, 713, 663, 412, 693, 342, 606, 
    106         134, 108, 571, 364, 631, 212, 174, 643, 304, 329, 
    107         343, 97, 430, 751, 497, 314, 983, 374, 822, 928, 
    108         140, 206, 73, 263, 980, 736, 876, 478, 430, 305, 
    109         170, 514, 364, 692, 829, 82, 855, 953, 676, 246, 
    110         369, 970, 294, 750, 807, 827, 150, 790, 288, 923, 
    111         804, 378, 215, 828, 592, 281, 565, 555, 710, 82, 
    112         896, 831, 547, 261, 524, 462, 293, 465, 502, 56, 
    113         661, 821, 976, 991, 658, 869, 905, 758, 745, 193, 
    114         768, 550, 608, 933, 378, 286, 215, 979, 792, 961, 
    115         61, 688, 793, 644, 986, 403, 106, 366, 905, 644, 
    116         372, 567, 466, 434, 645, 210, 389, 550, 919, 135, 
    117         780, 773, 635, 389, 707, 100, 626, 958, 165, 504, 
    118         920, 176, 193, 713, 857, 265, 203, 50, 668, 108, 
    119         645, 990, 626, 197, 510, 357, 358, 850, 858, 364, 
    120         936, 638 
    121     }; 
     67  int[] R_NUMS = { 
     68    619, 720, 127, 481, 931, 816, 813, 233, 566, 247, 
     69    985, 724, 205, 454, 863, 491, 741, 242, 949, 214, 
     70    733, 859, 335, 708, 621, 574, 73, 654, 730, 472, 
     71    419, 436, 278, 496, 867, 210, 399, 680, 480, 51, 
     72    878, 465, 811, 169, 869, 675, 611, 697, 867, 561, 
     73    862, 687, 507, 283, 482, 129, 807, 591, 733, 623, 
     74    150, 238, 59, 379, 684, 877, 625, 169, 643, 105, 
     75    170, 607, 520, 932, 727, 476, 693, 425, 174, 647, 
     76    73, 122, 335, 530, 442, 853, 695, 249, 445, 515, 
     77    909, 545, 703, 919, 874, 474, 882, 500, 594, 612, 
     78    641, 801, 220, 162, 819, 984, 589, 513, 495, 799, 
     79    161, 604, 958, 533, 221, 400, 386, 867, 600, 782, 
     80    382, 596, 414, 171, 516, 375, 682, 485, 911, 276, 
     81    98, 553, 163, 354, 666, 933, 424, 341, 533, 870, 
     82    227, 730, 475, 186, 263, 647, 537, 686, 600, 224, 
     83    469, 68, 770, 919, 190, 373, 294, 822, 808, 206, 
     84    184, 943, 795, 384, 383, 461, 404, 758, 839, 887, 
     85    715, 67, 618, 276, 204, 918, 873, 777, 604, 560, 
     86    951, 160, 578, 722, 79, 804, 96, 409, 713, 940, 
     87    652, 934, 970, 447, 318, 353, 859, 672, 112, 785, 
     88    645, 863, 803, 350, 139, 93, 354, 99, 820, 908, 
     89    609, 772, 154, 274, 580, 184, 79, 626, 630, 742, 
     90    653, 282, 762, 623, 680, 81, 927, 626, 789, 125, 
     91    411, 521, 938, 300, 821, 78, 343, 175, 128, 250, 
     92    170, 774, 972, 275, 999, 639, 495, 78, 352, 126, 
     93    857, 956, 358, 619, 580, 124, 737, 594, 701, 612, 
     94    669, 112, 134, 694, 363, 992, 809, 743, 168, 974, 
     95    944, 375, 748, 52, 600, 747, 642, 182, 862, 81, 
     96    344, 805, 988, 739, 511, 655, 814, 334, 249, 515, 
     97    897, 955, 664, 981, 649, 113, 974, 459, 893, 228, 
     98    433, 837, 553, 268, 926, 240, 102, 654, 459, 51, 
     99    686, 754, 806, 760, 493, 403, 415, 394, 687, 700, 
     100    946, 670, 656, 610, 738, 392, 760, 799, 887, 653, 
     101    978, 321, 576, 617, 626, 502, 894, 679, 243, 440, 
     102    680, 879, 194, 572, 640, 724, 926, 56, 204, 700, 
     103    707, 151, 457, 449, 797, 195, 791, 558, 945, 679, 
     104    297, 59, 87, 824, 713, 663, 412, 693, 342, 606, 
     105    134, 108, 571, 364, 631, 212, 174, 643, 304, 329, 
     106    343, 97, 430, 751, 497, 314, 983, 374, 822, 928, 
     107    140, 206, 73, 263, 980, 736, 876, 478, 430, 305, 
     108    170, 514, 364, 692, 829, 82, 855, 953, 676, 246, 
     109    369, 970, 294, 750, 807, 827, 150, 790, 288, 923, 
     110    804, 378, 215, 828, 592, 281, 565, 555, 710, 82, 
     111    896, 831, 547, 261, 524, 462, 293, 465, 502, 56, 
     112    661, 821, 976, 991, 658, 869, 905, 758, 745, 193, 
     113    768, 550, 608, 933, 378, 286, 215, 979, 792, 961, 
     114    61, 688, 793, 644, 986, 403, 106, 366, 905, 644, 
     115    372, 567, 466, 434, 645, 210, 389, 550, 919, 135, 
     116    780, 773, 635, 389, 707, 100, 626, 958, 165, 504, 
     117    920, 176, 193, 713, 857, 265, 203, 50, 668, 108, 
     118    645, 990, 626, 197, 510, 357, 358, 850, 858, 364, 
     119    936, 638 
     120  }; 
     121 
    122122} 
  • trunk/loci/formats/in/BaseTiffReader.java

    r1352 r1389  
    3030import java.nio.ShortBuffer; 
    3131import java.util.Hashtable; 
    32  
    3332import loci.formats.DataTools; 
    3433import loci.formats.FormatException; 
     
    6059  protected int numImages; 
    6160 
    62   /** The global min and max for each channel */ 
     61  /** The global min and max for each channel. */ 
    6362  protected Double[][] channelMinMax; 
    6463 
     
    436435          TiffTools.getIFDValue(ifd, TiffTools.HOST_COMPUTER); 
    437436        store.setExperimenter(firstName, lastName, email, 
    438                               null, null, null, null); 
     437          null, null, null, null); 
    439438      } 
    440439 
     
    443442 
    444443      // populate Logical Channel elements 
    445       for (int i=0; i < getSizeC(currentId); i++) 
    446       { 
     444      for (int i=0; i<getSizeC(currentId); i++) { 
    447445        try { 
    448446          setLogicalChannel(i); 
     
    676674 
    677675    if (isLittleEndian(currentId)) { 
    678       if (bitsPerSample == 16)  // Short 
    679       { 
     676      if (bitsPerSample == 16) { // short 
    680677        ShortBuffer buf = ByteBuffer.wrap(byteArray).asShortBuffer(); 
    681678        for (int i = 0; i < (byteArray.length / 2); i++) { 
     
    804801   */ 
    805802  public void getChannelGlobalMinMax() throws FormatException, IOException { 
    806     if (channelMinMax == null) 
     803    if (channelMinMax == null) { 
    807804      channelMinMax = new Double[getSizeC(currentId)][2]; 
     805    } 
    808806    else return; 
    809807 
    810     for (int c = 0; c < getSizeC(currentId); c++) 
    811     { 
     808    for (int c = 0; c < getSizeC(currentId); c++) { 
    812809      double min = Double.MAX_VALUE; 
    813810      double max = Double.MIN_VALUE; 
    814       for(int t = 0; t < getSizeT(currentId); t++) 
    815       { 
    816         for(int z = 0; z < getSizeZ(currentId); z++) 
    817         { 
     811      for (int t = 0; t < getSizeT(currentId); t++) { 
     812        for (int z = 0; z < getSizeZ(currentId); z++) { 
    818813          int index = getIndex(currentId, z, c, t); 
    819814          Plane2D plane = openPlane2D(currentId, index); 
    820           for (int x = 0; x < getSizeX(currentId); x++) 
    821           { 
    822             for (int y = 0; y < getSizeY(currentId); y++) 
    823             { 
     815          for (int x = 0; x < getSizeX(currentId); x++) { 
     816            for (int y = 0; y < getSizeY(currentId); y++) { 
    824817              double pixelValue = plane.getPixelValue(x, y); 
    825818              if (pixelValue < min) min = pixelValue; 
     
    842835  private void setLogicalChannel(int i) throws FormatException, IOException { 
    843836    getMetadataStore(currentId).setLogicalChannel( 
    844         i, 
    845         getChannelName(i), 
    846         getNdFilter(i), 
    847         getEmWave(i), 
    848         getExWave(i), 
    849         getPhotometricInterpretation(i), 
    850         getMode(i), // aquisition mode 
    851         null); 
     837      i, 
     838      getChannelName(i), 
     839      getNdFilter(i), 
     840      getEmWave(i), 
     841      getExWave(i), 
     842      getPhotometricInterpretation(i), 
     843      getMode(i), // aquisition mode 
     844      null); 
    852845  } 
    853846 
  • trunk/loci/formats/in/BioRadReader.java

    r1264 r1389  
    6363  }; 
    6464 
    65  
    6665  // -- Fields -- 
    6766 
     
    8180  private boolean byteFormat; 
    8281 
    83  
    8482  // -- Constructor -- 
    8583 
    8684  /** Constructs a new BioRadReader. */ 
    8785  public BioRadReader() { super("Bio-Rad PIC", "pic"); } 
    88  
    8986 
    9087  // -- FormatReader API methods -- 
     
    466463  } 
    467464 
    468   public String noteString(int n, int l, int s, int t, int x, int y, String p) 
    469   { 
     465  public String noteString(int n, int l, int s, int t, int x, int y, String p) { 
    470466    StringBuffer sb = new StringBuffer(100); 
    471467    sb.append("level="); 
     
    486482  } 
    487483 
    488  
    489484  // -- Main method -- 
    490485 
  • trunk/loci/formats/in/Bits.java

    r1334 r1389  
    3030 * @author Chris Allan callan at blackcat.ca 
    3131 */ 
    32 class Bits 
    33 { 
    34   static short swap(short x) { 
     32public abstract class Bits { 
     33 
     34  // -- Constructor -- 
     35 
     36  private Bits() { } 
     37 
     38  // -- Utility methods -- 
     39 
     40  public static short swap(short x) { 
    3541    return (short) ((x << 8) | ((x >> 8) & 0xFF)); 
    3642  } 
    3743 
    38   static char swap(char x) { 
     44  public static char swap(char x) { 
    3945    return (char) ((x << 8) | ((x >> 8) & 0xFF)); 
    4046  } 
    4147 
    42   static int swap(int x) { 
    43     return (int) ((swap((short)x) << 16) | (swap((short)(x >> 16)) & 0xFFFF)); 
     48  public static int swap(int x) { 
     49    return (int) ((swap((short) x) << 16) | (swap((short) (x >> 16)) & 0xFFFF)); 
    4450  } 
    4551 
    46   static long swap(long x) { 
    47     return (long) (((long)swap((int)(x)) << 32) | 
    48       ((long)swap((int)(x >> 32)) & 0xFFFFFFFFL)); 
     52  public static long swap(long x) { 
     53    return (long) (((long) swap((int) x) << 32) | 
     54      ((long) swap((int) (x >> 32)) & 0xFFFFFFFFL)); 
    4955  } 
    5056} 
  • trunk/loci/formats/in/CBZip2InputStream.java

    r1264 r1389  
    3030 *  You may obtain a copy of the License at 
    3131 * 
    32  *      http://www.apache.org/licenses/LICENSE-2.0 
     32 *    http://www.apache.org/licenses/LICENSE-2.0 
    3333 * 
    3434 *  Unless required by applicable law or agreed to in writing, software 
     
    5656 */ 
    5757public class CBZip2InputStream extends InputStream implements BZip2Constants { 
    58     private static void cadvise() { 
    59         System.out.println("CRC Error"); 
    60         //throw new CCoruptionError(); 
    61     } 
    62  
    63     private static void compressedStreamEOF() { 
    64         cadvise(); 
    65     } 
    66  
    67     private void makeMaps() { 
    68         int q; 
    69         nInUse = 0; 
    70         for (q = 0; q < 256; q++) { 
    71             if (inUse[q]) { 
    72                 seqToUnseq[nInUse] = (char) q; 
    73                 unseqToSeq[q] = (char) nInUse; 
    74                 nInUse++; 
     58  private static void cadvise() { 
     59    System.out.println("CRC Error"); 
     60    //throw new CCoruptionError(); 
     61  } 
     62 
     63  private static void compressedStreamEOF() { 
     64    cadvise(); 
     65  } 
     66 
     67  private void makeMaps() { 
     68    int q; 
     69    nInUse = 0; 
     70    for (q = 0; q < 256; q++) { 
     71      if (inUse[q]) { 
     72        seqToUnseq[nInUse] = (char) q; 
     73        unseqToSeq[q] = (char) nInUse; 
     74        nInUse++; 
     75      } 
     76    } 
     77  } 
     78 
     79  /* 
     80    index of the last char in the block, so 
     81    the block size == last + 1. 
     82  */ 
     83  private int  last; 
     84 
     85  /* 
     86    index in zptr[] of original string after sorting. 
     87  */ 
     88  private int  origPtr; 
     89 
     90  /* 
     91    always: in the range 0 .. 9. 
     92    The current block size is 100000 * this number. 
     93  */ 
     94  private int blockSize100k; 
     95 
     96  private boolean blockRandomised; 
     97 
     98  private int bsBuff; 
     99  private int bsLive; 
     100  private CRC mCrc = new CRC(); 
     101 
     102  private boolean[] inUse = new boolean[256]; 
     103  private int nInUse; 
     104 
     105  private char[] seqToUnseq = new char[256]; 
     106  private char[] unseqToSeq = new char[256]; 
     107 
     108  private char[] selector = new char[MAX_SELECTORS]; 
     109  private char[] selectorMtf = new char[MAX_SELECTORS]; 
     110 
     111  private int[] tt; 
     112  private char[] ll8; 
     113 
     114  /* 
     115    freq table collected to save a pass over the data 
     116    during decompression. 
     117  */ 
     118  private int[] unzftab = new int[256]; 
     119 
     120  private int[][] limit = new int[N_GROUPS][MAX_ALPHA_SIZE]; 
     121  private int[][] base = new int[N_GROUPS][MAX_ALPHA_SIZE]; 
     122  private int[][] perm = new int[N_GROUPS][MAX_ALPHA_SIZE]; 
     123  private int[] minLens = new int[N_GROUPS]; 
     124 
     125  private InputStream bsStream; 
     126 
     127  private boolean streamEnd = false; 
     128 
     129  private int currentChar = -1; 
     130 
     131  private static final int START_BLOCK_STATE = 1; 
     132  private static final int RAND_PART_A_STATE = 2; 
     133  private static final int RAND_PART_B_STATE = 3; 
     134  private static final int RAND_PART_C_STATE = 4; 
     135  private static final int NO_RAND_PART_A_STATE = 5; 
     136  private static final int NO_RAND_PART_B_STATE = 6; 
     137  private static final int NO_RAND_PART_C_STATE = 7; 
     138 
     139  private int currentState = START_BLOCK_STATE; 
     140 
     141  private int storedBlockCRC, storedCombinedCRC; 
     142  private int computedBlockCRC, computedCombinedCRC; 
     143 
     144  protected int i2, count, chPrev, ch2; 
     145  protected int i, tPos; 
     146  protected int rNToGo = 0; 
     147  protected int rTPos  = 0; 
     148  protected int j2; 
     149  protected char z; 
     150 
     151  public CBZip2InputStream(InputStream zStream) { 
     152    ll8 = null; 
     153    tt = null; 
     154    bsSetStream(zStream); 
     155    initialize(); 
     156    initBlock(); 
     157    setupBlock(); 
     158  } 
     159 
     160  public int read() { 
     161    if (streamEnd) { 
     162      return -1; 
     163    } 
     164    else { 
     165      int retChar = currentChar; 
     166      switch (currentState) { 
     167      case START_BLOCK_STATE: 
     168        break; 
     169      case RAND_PART_A_STATE: 
     170        break; 
     171      case RAND_PART_B_STATE: 
     172        setupRandPartB(); 
     173        break; 
     174      case RAND_PART_C_STATE: 
     175        setupRandPartC(); 
     176        break; 
     177      case NO_RAND_PART_A_STATE: 
     178        break; 
     179      case NO_RAND_PART_B_STATE: 
     180        setupNoRandPartB(); 
     181        break; 
     182      case NO_RAND_PART_C_STATE: 
     183        setupNoRandPartC(); 
     184        break; 
     185      default: 
     186        break; 
     187      } 
     188      return retChar; 
     189    } 
     190  } 
     191 
     192  private void initialize() { 
     193    char magic3, magic4; 
     194    magic3 = bsGetUChar(); 
     195    magic4 = bsGetUChar(); 
     196 
     197    if (magic3 != 'h' || magic4 < '1' || magic4 > '9') { 
     198      bsFinishedWithStream(); 
     199      streamEnd = true; 
     200      return; 
     201    } 
     202 
     203    setDecompressStructureSizes(magic4 - '0'); 
     204    computedCombinedCRC = 0; 
     205  } 
     206 
     207  private void initBlock() { 
     208    char magic1, magic2, magic3, magic4; 
     209    char magic5, magic6; 
     210    magic1 = bsGetUChar(); 
     211    magic2 = bsGetUChar(); 
     212    magic3 = bsGetUChar(); 
     213    magic4 = bsGetUChar(); 
     214    magic5 = bsGetUChar(); 
     215    magic6 = bsGetUChar(); 
     216    if (magic1 == 0x17 && magic2 == 0x72 && magic3 == 0x45 && 
     217      magic4 == 0x38 && magic5 == 0x50 && magic6 == 0x90) 
     218    { 
     219      complete(); 
     220      return; 
     221    } 
     222 
     223    if (magic1 != 0x31 || magic2 != 0x41 || magic3 != 0x59 || 
     224      magic4 != 0x26 || magic5 != 0x53 || magic6 != 0x59) 
     225    { 
     226      badBlockHeader(); 
     227      streamEnd = true; 
     228      return; 
     229    } 
     230 
     231    storedBlockCRC = bsGetInt32(); 
     232 
     233    if (bsR(1) == 1) { 
     234      blockRandomised = true; 
     235    } 
     236    else { 
     237      blockRandomised = false; 
     238    } 
     239 
     240    //currBlockNo++; 
     241    getAndMoveToFrontDecode(); 
     242 
     243    mCrc.initialiseCRC(); 
     244    currentState = START_BLOCK_STATE; 
     245  } 
     246 
     247  private void endBlock() { 
     248    computedBlockCRC = mCrc.getFinalCRC(); 
     249    // A bad CRC is considered a fatal error. 
     250    if (storedBlockCRC != computedBlockCRC) { 
     251      crcError(); 
     252    } 
     253 
     254    computedCombinedCRC = (computedCombinedCRC << 1) | 
     255      (computedCombinedCRC >>> 31); 
     256    computedCombinedCRC ^= computedBlockCRC; 
     257  } 
     258 
     259  private void complete() { 
     260    storedCombinedCRC = bsGetInt32(); 
     261    if (storedCombinedCRC != computedCombinedCRC) { 
     262      crcError(); 
     263    } 
     264 
     265    bsFinishedWithStream(); 
     266    streamEnd = true; 
     267  } 
     268 
     269  private static void blockOverrun() { 
     270    cadvise(); 
     271  } 
     272 
     273  private static void badBlockHeader() { 
     274    cadvise(); 
     275  } 
     276 
     277  private static void crcError() { 
     278    cadvise(); 
     279  } 
     280 
     281  private void bsFinishedWithStream() { 
     282    try { 
     283      if (this.bsStream != null) { 
     284        if (this.bsStream != System.in) { 
     285          this.bsStream.close(); 
     286          this.bsStream = null; 
     287        } 
     288      } 
     289    } 
     290    catch (IOException ioe) { 
     291      //ignore 
     292    } 
     293  } 
     294 
     295  private void bsSetStream(InputStream f) { 
     296    bsStream = f; 
     297    bsLive = 0; 
     298    bsBuff = 0; 
     299  } 
     300 
     301  private int bsR(int n) { 
     302    int v; 
     303    while (bsLive < n) { 
     304      int zzi; 
     305      char thech = 0; 
     306      try { 
     307        thech = (char) bsStream.read(); 
     308      } 
     309      catch (IOException e) { 
     310        compressedStreamEOF(); 
     311      } 
     312      if (thech == -1) { 
     313        compressedStreamEOF(); 
     314      } 
     315      zzi = thech; 
     316      bsBuff = (bsBuff << 8) | (zzi & 0xff); 
     317      bsLive += 8; 
     318    } 
     319 
     320    v = (bsBuff >> (bsLive - n)) & ((1 << n) - 1); 
     321    bsLive -= n; 
     322    return v; 
     323  } 
     324 
     325  private char bsGetUChar() { 
     326    return (char) bsR(8); 
     327  } 
     328 
     329  private int bsGetint() { 
     330    int u = 0; 
     331    u = (u << 8) | bsR(8); 
     332    u = (u << 8) | bsR(8); 
     333    u = (u << 8) | bsR(8); 
     334    u = (u << 8) | bsR(8); 
     335    return u; 
     336  } 
     337 
     338  private int bsGetIntVS(int numBits) { 
     339    return (int) bsR(numBits); 
     340  } 
     341 
     342  private int bsGetInt32() { 
     343    return (int) bsGetint(); 
     344  } 
     345 
     346  private void hbCreateDecodeTables(int[] tLimit, int[] tBase, 
     347    int[] tPerm, char[] length, int minLen, int maxLen, int alphaSize) 
     348  { 
     349    int pp, q, j, vec; 
     350 
     351    pp = 0; 
     352    for (q = minLen; q <= maxLen; q++) { 
     353      for (j = 0; j < alphaSize; j++) { 
     354        if (length[j] == q) { 
     355          tPerm[pp] = j; 
     356          pp++; 
     357        } 
     358      } 
     359    } 
     360 
     361    for (q = 0; q < MAX_CODE_LEN; q++) { 
     362      tBase[q] = 0; 
     363    } 
     364    for (q = 0; q < alphaSize; q++) { 
     365      tBase[length[q] + 1]++; 
     366    } 
     367 
     368    for (q = 1; q < MAX_CODE_LEN; q++) { 
     369      tBase[q] += tBase[q - 1]; 
     370    } 
     371 
     372    for (q = 0; q < MAX_CODE_LEN; q++) { 
     373      tLimit[q] = 0; 
     374    } 
     375    vec = 0; 
     376 
     377    for (q = minLen; q <= maxLen; q++) { 
     378      vec += (tBase[q + 1] - tBase[q]); 
     379      tLimit[q] = vec - 1; 
     380      vec <<= 1; 
     381    } 
     382    for (q = minLen + 1; q <= maxLen; q++) { 
     383      tBase[q] = ((tLimit[q - 1] + 1) << 1) - tBase[q]; 
     384    } 
     385  } 
     386 
     387  private void recvDecodingTables() { 
     388    char[][] len = new char[N_GROUPS][MAX_ALPHA_SIZE]; 
     389    int q, j, t, nGroups, nSelectors, alphaSize; 
     390    int minLen, maxLen; 
     391    boolean[] inUse16 = new boolean[16]; 
     392 
     393    /* Receive the mapping table */ 
     394    for (q = 0; q < 16; q++) { 
     395      if (bsR(1) == 1) { 
     396        inUse16[q] = true; 
     397      } 
     398      else { 
     399        inUse16[q] = false; 
     400      } 
     401    } 
     402 
     403    for (q = 0; q < 256; q++) { 
     404      inUse[q] = false; 
     405    } 
     406 
     407    for (q = 0; q < 16; q++) { 
     408      if (inUse16[q]) { 
     409        for (j = 0; j < 16; j++) { 
     410          if (bsR(1) == 1) { 
     411            inUse[q * 16 + j] = true; 
     412          } 
     413        } 
     414      } 
     415    } 
     416 
     417    makeMaps(); 
     418    alphaSize = nInUse + 2; 
     419 
     420    /* Now the selectors */ 
     421    nGroups = bsR(3); 
     422    nSelectors = bsR(15); 
     423    for (q = 0; q < nSelectors; q++) { 
     424      j = 0; 
     425      while (bsR(1) == 1) { 
     426        j++; 
     427      } 
     428      selectorMtf[q] = (char) j; 
     429    } 
     430 
     431    // undo the MTF values for the selectors. 
     432    char[] pos = new char[N_GROUPS]; 
     433    char tmp, v; 
     434    for (v = 0; v < nGroups; v++) { 
     435      pos[v] = v; 
     436    } 
     437 
     438    for (q = 0; q < nSelectors; q++) { 
     439      v = selectorMtf[q]; 
     440      tmp = pos[v]; 
     441      while (v > 0) { 
     442        pos[v] = pos[v - 1]; 
     443        v--; 
     444      } 
     445      pos[0] = tmp; 
     446      selector[q] = tmp; 
     447    } 
     448 
     449    /* Now the coding tables */ 
     450    for (t = 0; t < nGroups; t++) { 
     451      int curr = bsR(5); 
     452      for (q = 0; q < alphaSize; q++) { 
     453        while (bsR(1) == 1) { 
     454          if (bsR(1) == 0) { 
     455            curr++; 
     456          } 
     457          else { 
     458            curr--; 
     459          } 
     460        } 
     461        len[t][q] = (char) curr; 
     462      } 
     463    } 
     464 
     465    /* Create the Huffman decoding tables */ 
     466    for (t = 0; t < nGroups; t++) { 
     467      minLen = 32; 
     468      maxLen = 0; 
     469      for (q = 0; q < alphaSize; q++) { 
     470        if (len[t][q] > maxLen) { 
     471          maxLen = len[t][q]; 
     472        } 
     473        if (len[t][q] < minLen) { 
     474          minLen = len[t][q]; 
     475        } 
     476      } 
     477      hbCreateDecodeTables(limit[t], base[t], perm[t], 
     478        len[t], minLen, maxLen, alphaSize); 
     479      minLens[t] = minLen; 
     480    } 
     481  } 
     482 
     483  private void getAndMoveToFrontDecode() { 
     484    char[] yy = new char[256]; 
     485    int q, j, nextSym, limitLast; 
     486    int eob, groupNo, groupPos; 
     487 
     488    limitLast = BASE_BLOCK_SIZE * blockSize100k; 
     489    origPtr = bsGetIntVS(24); 
     490 
     491    recvDecodingTables(); 
     492    eob = nInUse + 1; 
     493    groupNo = -1; 
     494    groupPos = 0; 
     495 
     496    /* 
     497      Setting up the unzftab entries here is not strictly 
     498      necessary, but it does save having to do it later 
     499      in a separate pass, and so saves a block's worth of 
     500      cache misses. 
     501    */ 
     502    for (q = 0; q <= 255; q++) { 
     503      unzftab[i] = 0; 
     504    } 
     505 
     506    for (q = 0; q <= 255; q++) { 
     507      yy[q] = (char) q; 
     508    } 
     509 
     510    last = -1; 
     511 
     512    int zt, zn, zvec, zj; 
     513    if (groupPos == 0) { 
     514      groupNo++; 
     515      groupPos = G_SIZE; 
     516    } 
     517    groupPos--; 
     518    zt = selector[groupNo]; 
     519    zn = minLens[zt]; 
     520    zvec = bsR(zn); 
     521    while (zvec > limit[zt][zn]) { 
     522      zn++; 
     523      while (bsLive < 1) { 
     524        int zzi; 
     525        char thech = 0; 
     526        try { 
     527          thech = (char) bsStream.read(); 
     528        } 
     529        catch (IOException e) { 
     530          compressedStreamEOF(); 
     531        } 
     532        if (thech == -1) { 
     533          compressedStreamEOF(); 
     534        } 
     535        zzi = thech; 
     536        bsBuff = (bsBuff << 8) | (zzi & 0xff); 
     537        bsLive += 8; 
     538      } 
     539      zj = (bsBuff >> (bsLive - 1)) & 1; 
     540      bsLive--; 
     541      zvec = (zvec << 1) | zj; 
     542    } 
     543    nextSym = perm[zt][zvec - base[zt][zn]]; 
     544 
     545    while (true) { 
     546 
     547      if (nextSym == eob) { 
     548        break; 
     549      } 
     550 
     551      if (nextSym == RUNA || nextSym == RUNB) { 
     552        char ch; 
     553        int s = -1; 
     554        int n = 1; 
     555        do { 
     556          if (nextSym == RUNA) { 
     557            s = s + (0 + 1) * n; 
     558          } 
     559          else if (nextSym == RUNB) { 
     560            s = s + (1 + 1) * n; 
     561          } 
     562          n *= 2; 
     563 
     564          //int zt, zn, zvec, zj; 
     565          if (groupPos == 0) { 
     566            groupNo++; 
     567            groupPos = G_SIZE; 
     568          } 
     569          groupPos--; 
     570          zt = selector[groupNo]; 
     571          zn = minLens[zt]; 
     572          zvec = bsR(zn); 
     573          while (zvec > limit[zt][zn]) { 
     574            zn++; 
     575            while (bsLive < 1) { 
     576              int zzi; 
     577              char thech = 0; 
     578              try { 
     579                thech = (char) bsStream.read(); 
     580              } 
     581              catch (IOException e) { 
     582                compressedStreamEOF(); 
     583              } 
     584              if (thech == -1) { 
     585                compressedStreamEOF(); 
     586              } 
     587              zzi = thech; 
     588              bsBuff = (bsBuff << 8) | (zzi & 0xff); 
     589              bsLive += 8; 
    75590            } 
    76         } 
    77     } 
    78  
    79     /* 
    80       index of the last char in the block, so 
    81       the block size == last + 1. 
    82     */ 
    83     private int  last; 
    84  
    85     /* 
    86       index in zptr[] of original string after sorting. 
    87     */ 
    88     private int  origPtr; 
    89  
    90     /* 
    91       always: in the range 0 .. 9. 
    92       The current block size is 100000 * this number. 
    93     */ 
    94     private int blockSize100k; 
    95  
    96     private boolean blockRandomised; 
    97  
    98     private int bsBuff; 
    99     private int bsLive; 
    100     private CRC mCrc = new CRC(); 
    101  
    102     private boolean[] inUse = new boolean[256]; 
    103     private int nInUse; 
    104  
    105     private char[] seqToUnseq = new char[256]; 
    106     private char[] unseqToSeq = new char[256]; 
    107  
    108     private char[] selector = new char[MAX_SELECTORS]; 
    109     private char[] selectorMtf = new char[MAX_SELECTORS]; 
    110  
    111     private int[] tt; 
    112     private char[] ll8; 
    113  
    114     /* 
    115       freq table collected to save a pass over the data 
    116       during decompression. 
    117     */ 
    118     private int[] unzftab = new int[256]; 
    119  
    120     private int[][] limit = new int[N_GROUPS][MAX_ALPHA_SIZE]; 
    121     private int[][] base = new int[N_GROUPS][MAX_ALPHA_SIZE]; 
    122     private int[][] perm = new int[N_GROUPS][MAX_ALPHA_SIZE]; 
    123     private int[] minLens = new int[N_GROUPS]; 
    124  
    125     private InputStream bsStream; 
    126  
    127     private boolean streamEnd = false; 
    128  
    129     private int currentChar = -1; 
    130  
    131     private static final int START_BLOCK_STATE = 1; 
    132     private static final int RAND_PART_A_STATE = 2; 
    133     private static final int RAND_PART_B_STATE = 3; 
    134     private static final int RAND_PART_C_STATE = 4; 
    135     private static final int NO_RAND_PART_A_STATE = 5; 
    136     private static final int NO_RAND_PART_B_STATE = 6; 
    137     private static final int NO_RAND_PART_C_STATE = 7; 
    138  
    139     private int currentState = START_BLOCK_STATE; 
    140  
    141     private int storedBlockCRC, storedCombinedCRC; 
    142     private int computedBlockCRC, computedCombinedCRC; 
    143  
    144     int i2, count, chPrev, ch2; 
    145     int i, tPos; 
    146     int rNToGo = 0; 
    147     int rTPos  = 0; 
    148     int j2; 
    149     char z; 
    150  
    151     public CBZip2InputStream(InputStream zStream) { 
    152         ll8 = null; 
    153         tt = null; 
    154         bsSetStream(zStream); 
    155         initialize(); 
    156         initBlock(); 
    157         setupBlock(); 
    158     } 
    159  
    160     public int read() { 
    161         if (streamEnd) { 
    162             return -1; 
    163         } else { 
    164             int retChar = currentChar; 
    165             switch(currentState) { 
    166             case START_BLOCK_STATE: 
    167                 break; 
    168             case RAND_PART_A_STATE: 
    169                 break; 
    170             case RAND_PART_B_STATE: 
    171                 setupRandPartB(); 
    172                 break; 
    173             case RAND_PART_C_STATE: 
    174                 setupRandPartC(); 
    175                 break; 
    176             case NO_RAND_PART_A_STATE: 
    177                 break; 
    178             case NO_RAND_PART_B_STATE: 
    179                 setupNoRandPartB(); 
    180                 break; 
    181             case NO_RAND_PART_C_STATE: 
    182                 setupNoRandPartC(); 
    183                 break; 
    184             default: 
    185                 break; 
    186             } 
    187             return retChar; 
    188         } 
    189     } 
    190  
    191     private void initialize() { 
    192         char magic3, magic4; 
    193         magic3 = bsGetUChar(); 
    194         magic4 = bsGetUChar(); 
    195  
    196         if (magic3 != 'h' || magic4 < '1' || magic4 > '9') { 
    197             bsFinishedWithStream(); 
    198             streamEnd = true; 
    199             return; 
    200         } 
    201  
    202         setDecompressStructureSizes(magic4 - '0'); 
    203         computedCombinedCRC = 0; 
    204     } 
    205  
    206     private void initBlock() { 
    207         char magic1, magic2, magic3, magic4; 
    208         char magic5, magic6; 
    209         magic1 = bsGetUChar(); 
    210         magic2 = bsGetUChar(); 
    211         magic3 = bsGetUChar(); 
    212         magic4 = bsGetUChar(); 
    213         magic5 = bsGetUChar(); 
    214         magic6 = bsGetUChar(); 
    215         if (magic1 == 0x17 && magic2 == 0x72 && magic3 == 0x45 
    216             && magic4 == 0x38 && magic5 == 0x50 && magic6 == 0x90) { 
    217             complete(); 
    218             return; 
    219         } 
    220  
    221         if (magic1 != 0x31 || magic2 != 0x41 || magic3 != 0x59 
    222             || magic4 != 0x26 || magic5 != 0x53 || magic6 != 0x59) { 
    223             badBlockHeader(); 
    224             streamEnd = true; 
    225             return; 
    226         } 
    227  
    228         storedBlockCRC = bsGetInt32(); 
    229  
    230         if (bsR(1) == 1) { 
    231             blockRandomised = true; 
    232         } else { 
    233             blockRandomised = false; 
    234         } 
    235  
    236         //        currBlockNo++; 
    237         getAndMoveToFrontDecode(); 
    238  
    239         mCrc.initialiseCRC(); 
    240         currentState = START_BLOCK_STATE; 
    241     } 
    242  
    243     private void endBlock() { 
    244         computedBlockCRC = mCrc.getFinalCRC(); 
    245         /* A bad CRC is considered a fatal error. */ 
    246         if (storedBlockCRC != computedBlockCRC) { 
    247             crcError(); 
    248         } 
    249  
    250         computedCombinedCRC = (computedCombinedCRC << 1) 
    251             | (computedCombinedCRC >>> 31); 
    252         computedCombinedCRC ^= computedBlockCRC; 
    253     } 
    254  
    255     private void complete() { 
    256         storedCombinedCRC = bsGetInt32(); 
    257         if (storedCombinedCRC != computedCombinedCRC) { 
    258             crcError(); 
    259         } 
    260  
    261         bsFinishedWithStream(); 
    262         streamEnd = true; 
    263     } 
    264  
    265     private static void blockOverrun() { 
    266         cadvise(); 
    267     } 
    268  
    269     private static void badBlockHeader() { 
    270         cadvise(); 
    271     } 
    272  
    273     private static void crcError() { 
    274         cadvise(); 
    275     } 
    276  
    277     private void bsFinishedWithStream() { 
    278         try { 
    279             if (this.bsStream != null) { 
    280                 if (this.bsStream != System.in) { 
    281                     this.bsStream.close(); 
    282                     this.bsStream = null; 
    283                 } 
    284             } 
    285         } catch (IOException ioe) { 
    286             //ignore 
    287         } 
    288     } 
    289  
    290     private void bsSetStream(InputStream f) { 
    291         bsStream = f; 
    292         bsLive = 0; 
    293         bsBuff = 0; 
    294     } 
    295  
    296     private int bsR(int n) { 
    297         int v; 
    298         while (bsLive < n) { 
     591            zj = (bsBuff >> (bsLive - 1)) & 1; 
     592            bsLive--; 
     593            zvec = (zvec << 1) | zj; 
     594          } 
     595          nextSym = perm[zt][zvec - base[zt][zn]]; 
     596        } 
     597        while (nextSym == RUNA || nextSym == RUNB); 
     598 
     599        s++; 
     600        ch = seqToUnseq[yy[0]]; 
     601        unzftab[ch] += s; 
     602 
     603        while (s > 0) { 
     604          last++; 
     605          ll8[last] = ch; 
     606          s--; 
     607        } 
     608 
     609        if (last >= limitLast) { 
     610          blockOverrun(); 
     611        } 
     612        continue; 
     613      } 
     614      else { 
     615        char tmp; 
     616        last++; 
     617        if (last >= limitLast) { 
     618          blockOverrun(); 
     619        } 
     620 
     621        tmp = yy[nextSym - 1]; 
     622        unzftab[seqToUnseq[tmp]]++; 
     623        ll8[last] = seqToUnseq[tmp]; 
     624 
     625        /* 
     626          This loop is hammered during decompression, 
     627          hence the unrolling. 
     628 
     629          for (j = nextSym-1; j > 0; j--) yy[j] = yy[j-1]; 
     630        */ 
     631 
     632        j = nextSym - 1; 
     633        for (; j > 3; j -= 4) { 
     634          yy[j]   = yy[j - 1]; 
     635          yy[j - 1] = yy[j - 2]; 
     636          yy[j - 2] = yy[j - 3]; 
     637          yy[j - 3] = yy[j - 4]; 
     638        } 
     639        for (; j > 0; j--) { 
     640          yy[j] = yy[j - 1]; 
     641        } 
     642 
     643        yy[0] = tmp; 
     644 
     645        //int zt, zn, zvec, zj; 
     646        if (groupPos == 0) { 
     647          groupNo++; 
     648          groupPos = G_SIZE; 
     649        } 
     650        groupPos--; 
     651        zt = selector[groupNo]; 
     652        zn = minLens[zt]; 
     653        zvec = bsR(zn); 
     654        while (zvec > limit[zt][zn]) { 
     655          zn++; 
     656          while (bsLive < 1) { 
    299657            int zzi; 
    300658            char thech = 0; 
    301659            try { 
    302                 thech = (char) bsStream.read(); 
    303             } catch (IOException e) { 
    304                 compressedStreamEOF(); 
     660              thech = (char) bsStream.read(); 
    305661            } 
    306             if (thech == -1) { 
    307                 compressedStreamEOF(); 
     662            catch (IOException e) { 
     663              compressedStreamEOF(); 
    308664            } 
    309665            zzi = thech; 
    310666            bsBuff = (bsBuff << 8) | (zzi & 0xff); 
    311667            bsLive += 8; 
    312         } 
    313  
    314         v = (bsBuff >> (bsLive - n)) & ((1 << n) - 1); 
    315         bsLive -= n; 
    316         return v; 
    317     } 
    318  
    319     private char bsGetUChar() { 
    320         return (char) bsR(8); 
    321     } 
    322  
    323     private int bsGetint() { 
    324         int u = 0; 
    325         u = (u << 8) | bsR(8); 
    326         u = (u << 8) | bsR(8); 
    327         u = (u << 8) | bsR(8); 
    328         u = (u << 8) | bsR(8); 
    329         return u; 
    330     } 
    331  
    332     private int bsGetIntVS(int numBits) { 
    333         return (int) bsR(numBits); 
    334     } 
    335  
    336     private int bsGetInt32() { 
    337         return (int) bsGetint(); 
    338     } 
    339  
    340     private void hbCreateDecodeTables(int[] limit, int[] base, 
    341                                       int[] perm, char[] length, 
    342                                       int minLen, int maxLen, int alphaSize) { 
    343         int pp, q, j, vec; 
    344  
    345         pp = 0; 
    346         for (q = minLen; q <= maxLen; q++) { 
    347             for (j = 0; j < alphaSize; j++) { 
    348                 if (length[j] == q) { 
    349                     perm[pp] = j; 
    350                     pp++; 
    351                 } 
    352             } 
    353         } 
    354  
    355         for (q = 0; q < MAX_CODE_LEN; q++) { 
    356             base[q] = 0; 
    357         } 
    358         for (q = 0; q < alphaSize; q++) { 
    359             base[length[q] + 1]++; 
    360         } 
    361  
    362         for (q = 1; q < MAX_CODE_LEN; q++) { 
    363             base[q] += base[q - 1]; 
    364         } 
    365  
    366         for (q = 0; q < MAX_CODE_LEN; q++) { 
    367             limit[q] = 0; 
    368         } 
    369         vec = 0; 
    370  
    371         for (q = minLen; q <= maxLen; q++) { 
    372             vec += (base[q + 1] - base[q]); 
    373             limit[q] = vec - 1; 
    374             vec <<= 1; 
    375         } 
    376         for (q = minLen + 1; q <= maxLen; q++) { 
    377             base[q] = ((limit[q - 1] + 1) << 1) - base[q]; 
    378         } 
    379     } 
    380  
    381     private void recvDecodingTables() { 
    382         char len[][] = new char[N_GROUPS][MAX_ALPHA_SIZE]; 
    383         int q, j, t, nGroups, nSelectors, alphaSize; 
    384         int minLen, maxLen; 
    385         boolean[] inUse16 = new boolean[16]; 
    386  
    387         /* Receive the mapping table */ 
    388         for (q = 0; q < 16; q++) { 
    389             if (bsR(1) == 1) { 
    390                 inUse16[q] = true; 
    391             } else { 
    392                 inUse16[q] = false; 
    393             } 
    394         } 
    395  
    396         for (q = 0; q < 256; q++) { 
    397             inUse[q] = false; 
    398         } 
    399  
    400         for (q = 0; q < 16; q++) { 
    401             if (inUse16[q]) { 
    402                 for (j = 0; j < 16; j++) { 
    403                     if (bsR(1) == 1) { 
    404                         inUse[q * 16 + j] = true; 
    405                     } 
    406                 } 
    407             } 
    408         } 
    409  
    410         makeMaps(); 
    411         alphaSize = nInUse + 2; 
    412  
    413         /* Now the selectors */ 
    414         nGroups = bsR(3); 
    415         nSelectors = bsR(15); 
    416         for (q = 0; q < nSelectors; q++) { 
    417             j = 0; 
    418             while (bsR(1) == 1) { 
    419                 j++; 
    420             } 
    421             selectorMtf[q] = (char) j; 
    422         } 
    423  
    424         /* Undo the MTF values for the selectors. */ 
    425         { 
    426             char[] pos = new char[N_GROUPS]; 
    427             char tmp, v; 
    428             for (v = 0; v < nGroups; v++) { 
    429                 pos[v] = v; 
    430             } 
    431  
    432             for (q = 0; q < nSelectors; q++) { 
    433                 v = selectorMtf[q]; 
    434                 tmp = pos[v]; 
    435                 while (v > 0) { 
    436                     pos[v] = pos[v - 1]; 
    437                     v--; 
    438                 } 
    439                 pos[0] = tmp; 
    440                 selector[q] = tmp; 
    441             } 
    442         } 
    443  
    444         /* Now the coding tables */ 
    445         for (t = 0; t < nGroups; t++) { 
    446             int curr = bsR(5); 
    447             for (q = 0; q < alphaSize; q++) { 
    448                 while (bsR(1) == 1) { 
    449                     if (bsR(1) == 0) { 
    450                         curr++; 
    451                     } else { 
    452                         curr--; 
    453                     } 
    454                 } 
    455                 len[t][q] = (char) curr; 
    456             } 
    457         } 
    458  
    459         /* Create the Huffman decoding tables */ 
    460         for (t = 0; t < nGroups; t++) { 
    461             minLen = 32; 
    462             maxLen = 0; 
    463             for (q = 0; q < alphaSize; q++) { 
    464                 if (len[t][q] > maxLen) { 
    465                     maxLen = len[t][q]; 
    466                 } 
    467                 if (len[t][q] < minLen) { 
    468                     minLen = len[t][q]; 
    469                 } 
    470             } 
    471             hbCreateDecodeTables(limit[t], base[t], perm[t], len[t], minLen, 
    472                                  maxLen, alphaSize); 
    473             minLens[t] = minLen; 
    474         } 
    475     } 
    476  
    477     private void getAndMoveToFrontDecode() { 
    478         char[] yy = new char[256]; 
    479         int q, j, nextSym, limitLast; 
    480         int eob, groupNo, groupPos; 
    481  
    482         limitLast = BASE_BLOCK_SIZE * blockSize100k; 
    483         origPtr = bsGetIntVS(24); 
    484  
    485         recvDecodingTables(); 
    486         eob = nInUse + 1; 
    487         groupNo = -1; 
    488         groupPos = 0; 
    489  
    490         /* 
    491           Setting up the unzftab entries here is not strictly 
    492           necessary, but it does save having to do it later 
    493           in a separate pass, and so saves a block's worth of 
    494           cache misses. 
    495         */ 
    496         for (q = 0; q <= 255; q++) { 
    497             unzftab[i] = 0; 
    498         } 
    499  
    500         for (q = 0; q <= 255; q++) { 
    501             yy[q] = (char) q; 
    502         } 
    503  
    504         last = -1; 
    505  
    506         { 
    507             int zt, zn, zvec, zj; 
    508             if (groupPos == 0) { 
    509                 groupNo++; 
    510                 groupPos = G_SIZE; 
    511             } 
    512             groupPos--; 
    513             zt = selector[groupNo]; 
    514             zn = minLens[zt]; 
    515             zvec = bsR(zn); 
    516             while (zvec > limit[zt][zn]) { 
    517                 zn++; 
    518                 { 
    519                     { 
    520                         while (bsLive < 1) { 
    521                             int zzi; 
    522                             char thech = 0; 
    523                             try { 
    524                                 thech = (char) bsStream.read(); 
    525                             } catch (IOException e) { 
    526                                 compressedStreamEOF(); 
    527                             } 
    528                             if (thech == -1) { 
    529                                 compressedStreamEOF(); 
    530                             } 
    531                             zzi = thech; 
    532                             bsBuff = (bsBuff << 8) | (zzi & 0xff); 
    533                             bsLive += 8; 
    534                         } 
    535                     } 
    536                     zj = (bsBuff >> (bsLive - 1)) & 1; 
    537                     bsLive--; 
    538                 } 
    539                 zvec = (zvec << 1) | zj; 
    540             } 
    541             nextSym = perm[zt][zvec - base[zt][zn]]; 
    542         } 
    543  
    544         while (true) { 
    545  
    546             if (nextSym == eob) { 
    547                 break; 
    548             } 
    549  
    550             if (nextSym == RUNA || nextSym == RUNB) { 
    551                 char ch; 
    552                 int s = -1; 
    553                 int n = 1; 
    554                 do { 
    555                     if (nextSym == RUNA) { 
    556                         s = s + (0 + 1) * n; 
    557                     } else if (nextSym == RUNB) { 
    558                         s = s + (1 + 1) * n; 
    559                            } 
    560                     n *= 2; 
    561                     { 
    562                         int zt, zn, zvec, zj; 
    563                         if (groupPos == 0) { 
    564                             groupNo++; 
    565                             groupPos = G_SIZE; 
    566                         } 
    567                         groupPos--; 
    568                         zt = selector[groupNo]; 
    569                         zn = minLens[zt]; 
    570                         zvec = bsR(zn); 
    571                         while (zvec > limit[zt][zn]) { 
    572                             zn++; 
    573                             { 
    574                                 { 
    575                                     while (bsLive < 1) { 
    576                                         int zzi; 
    577                                         char thech = 0; 
    578                                         try { 
    579                                             thech = (char) bsStream.read(); 
    580                                         } catch (IOException e) { 
    581                                             compressedStreamEOF(); 
    582                                         } 
    583                                         if (thech == -1) { 
    584                                             compressedStreamEOF(); 
    585                                         } 
    586                                         zzi = thech; 
    587                                         bsBuff = (bsBuff << 8) | (zzi & 0xff); 
    588                                         bsLive += 8; 
    589                                     } 
    590                                 } 
    591                                 zj = (bsBuff >> (bsLive - 1)) & 1; 
    592                                 bsLive--; 
    593                             } 
    594                             zvec = (zvec << 1) | zj; 
    595                         } 
    596                         nextSym = perm[zt][zvec - base[zt][zn]]; 
    597                     } 
    598                 } while (nextSym == RUNA || nextSym == RUNB); 
    599  
    600                 s++; 
    601                 ch = seqToUnseq[yy[0]]; 
    602                 unzftab[ch] += s; 
    603  
    604                 while (s > 0) { 
    605                     last++; 
    606                     ll8[last] = ch; 
    607                     s--; 
    608                 } 
    609  
    610                 if (last >= limitLast) { 
    611                     blockOverrun(); 
    612                 } 
    613                 continue; 
    614             } else { 
    615                 char tmp; 
    616                 last++; 
    617                 if (last >= limitLast) { 
    618                     blockOverrun(); 
    619                 } 
    620  
    621                 tmp = yy[nextSym - 1]; 
    622                 unzftab[seqToUnseq[tmp]]++; 
    623                 ll8[last] = seqToUnseq[tmp]; 
    624  
    625                 /* 
    626                   This loop is hammered during decompression, 
    627                   hence the unrolling. 
    628  
    629                   for (j = nextSym-1; j > 0; j--) yy[j] = yy[j-1]; 
    630                 */ 
    631  
    632                 j = nextSym - 1; 
    633                 for (; j > 3; j -= 4) { 
    634                     yy[j]     = yy[j - 1]; 
    635                     yy[j - 1] = yy[j - 2]; 
    636                     yy[j - 2] = yy[j - 3]; 
    637                     yy[j - 3] = yy[j - 4]; 
    638                 } 
    639                 for (; j > 0; j--) { 
    640                     yy[j] = yy[j - 1]; 
    641                 } 
    642  
    643                 yy[0] = tmp; 
    644                 { 
    645                     int zt, zn, zvec, zj; 
    646                     if (groupPos == 0) { 
    647                         groupNo++; 
    648                         groupPos = G_SIZE; 
    649                     } 
    650                     groupPos--; 
    651                     zt = selector[groupNo]; 
    652                     zn = minLens[zt]; 
    653                     zvec = bsR(zn); 
    654                     while (zvec > limit[zt][zn]) { 
    655                         zn++; 
    656                         { 
    657                             { 
    658                                 while (bsLive < 1) { 
    659                                     int zzi; 
    660                                     char thech = 0; 
    661                                     try { 
    662                                         thech = (char) bsStream.read(); 
    663                                     } catch (IOException e) { 
    664                                         compressedStreamEOF(); 
    665                                     } 
    666                                     zzi = thech; 
    667                                     bsBuff = (bsBuff << 8) | (zzi & 0xff); 
    668                                     bsLive += 8; 
    669                                 } 
    670                             } 
    671                             zj = (bsBuff >> (bsLive - 1)) & 1; 
    672                             bsLive--; 
    673                         } 
    674                         zvec = (zvec << 1) | zj; 
    675                     } 
    676                     nextSym = perm[zt][zvec - base[zt][zn]]; 
    677                 } 
    678                 continue; 
    679             } 
    680         } 
    681     } 
    682  
    683     private void setupBlock() { 
    684         int[] cftab = new int[257]; 
    685         char ch; 
    686  
    687         cftab[0] = 0; 
    688         for (i = 1; i <= 256; i++) { 
    689             cftab[i] = unzftab[i - 1]; 
    690         } 
    691         for (i = 1; i <= 256; i++) { 
    692             cftab[i] += cftab[i - 1]; 
    693         } 
    694  
    695         for (i = 0; i <= last; i++) { 
    696             ch = (char) ll8[i]; 
    697             tt[cftab[ch]] = i; 
    698             cftab[ch]++; 
    699         } 
    700         cftab = null; 
    701  
    702         tPos = tt[origPtr]; 
    703  
    704         count = 0; 
    705         i2 = 0; 
    706         ch2 = 256;   /* not a char and not EOF */ 
    707  
    708         if (blockRandomised) { 
    709             rNToGo = 0; 
     668          } 
     669          zj = (bsBuff >> (bsLive - 1)) & 1; 
     670          bsLive--; 
     671          zvec = (zvec << 1) | zj; 
     672        } 
     673        nextSym = perm[zt][zvec - base[zt][zn]]; 
     674 
     675        continue; 
     676      } 
     677    } 
     678  } 
     679 
     680  private void setupBlock() { 
     681    int[] cftab = new int[257]; 
     682    char ch; 
     683 
     684    cftab[0] = 0; 
     685    for (i = 1; i <= 256; i++) { 
     686      cftab[i] = unzftab[i - 1]; 
     687    } 
     688    for (i = 1; i <= 256; i++) { 
     689      cftab[i] += cftab[i - 1]; 
     690    } 
     691 
     692    for (i = 0; i <= last; i++) { 
     693      ch = (char) ll8[i]; 
     694      tt[cftab[ch]] = i; 
     695      cftab[ch]++; 
     696    } 
     697    cftab = null; 
     698 
     699    tPos = tt[origPtr]; 
     700 
     701    count = 0; 
     702    i2 = 0; 
     703    ch2 = 256;   /* not a char and not EOF */ 
     704 
     705    if (blockRandomised) { 
     706      rNToGo = 0; 
     707      rTPos = 0; 
     708      setupRandPartA(); 
     709    } 
     710    else { 
     711      setupNoRandPartA(); 
     712    } 
     713  } 
     714 
     715  private void setupRandPartA() { 
     716    if (i2 <= last) { 
     717      chPrev = ch2; 
     718      ch2 = ll8[tPos]; 
     719      tPos = tt[tPos]; 
     720      if (rNToGo == 0) { 
     721        rNToGo = R_NUMS[rTPos]; 
     722        rTPos++; 
     723        if (rTPos == 512) { 
     724          rTPos = 0; 
     725        } 
     726      } 
     727      rNToGo--; 
     728      ch2 ^= (int) ((rNToGo == 1) ? 1 : 0); 
     729      i2++; 
     730 
     731      currentChar = ch2; 
     732      currentState = RAND_PART_B_STATE; 
     733      mCrc.updateCRC(ch2); 
     734    } 
     735    else { 
     736      endBlock(); 
     737      initBlock(); 
     738      setupBlock(); 
     739    } 
     740  } 
     741 
     742  private void setupNoRandPartA() { 
     743    if (i2 <= last) { 
     744      chPrev = ch2; 
     745      ch2 = ll8[tPos]; 
     746      tPos = tt[tPos]; 
     747      i2++; 
     748 
     749      currentChar = ch2; 
     750      currentState = NO_RAND_PART_B_STATE; 
     751      mCrc.updateCRC(ch2); 
     752    } 
     753    else { 
     754      endBlock(); 
     755      initBlock(); 
     756      setupBlock(); 
     757    } 
     758  } 
     759 
     760  private void setupRandPartB() { 
     761    if (ch2 != chPrev) { 
     762      currentState = RAND_PART_A_STATE; 
     763      count = 1; 
     764      setupRandPartA(); 
     765    } 
     766    else { 
     767      count++; 
     768      if (count >= 4) { 
     769        z = ll8[tPos]; 
     770        tPos = tt[tPos]; 
     771        if (rNToGo == 0) { 
     772          rNToGo = R_NUMS[rTPos]; 
     773          rTPos++; 
     774          if (rTPos == 512) { 
    710775            rTPos = 0; 
    711             setupRandPartA(); 
    712         } else { 
    713             setupNoRandPartA(); 
    714         } 
    715     } 
    716  
    717     private void setupRandPartA() { 
    718         if (i2 <= last) { 
    719             chPrev = ch2; 
    720             ch2 = ll8[tPos]; 
    721             tPos = tt[tPos]; 
    722             if (rNToGo == 0) { 
    723                 rNToGo = R_NUMS[rTPos]; 
    724                 rTPos++; 
    725                 if (rTPos == 512) { 
    726                     rTPos = 0; 
    727                 } 
    728             } 
    729             rNToGo--; 
    730             ch2 ^= (int) ((rNToGo == 1) ? 1 : 0); 
    731             i2++; 
    732  
    733             currentChar = ch2; 
    734             currentState = RAND_PART_B_STATE; 
    735             mCrc.updateCRC(ch2); 
    736         } else { 
    737             endBlock(); 
    738             initBlock(); 
    739             setupBlock(); 
    740         } 
    741     } 
    742  
    743     private void setupNoRandPartA() { 
    744         if (i2 <= last) { 
    745             chPrev = ch2; 
    746             ch2 = ll8[tPos]; 
    747             tPos = tt[tPos]; 
    748             i2++; 
    749  
    750             currentChar = ch2; 
    751             currentState = NO_RAND_PART_B_STATE; 
    752             mCrc.updateCRC(ch2); 
    753         } else { 
    754             endBlock(); 
    755             initBlock(); 
    756             setupBlock(); 
    757         } 
    758     } 
    759  
    760     private void setupRandPartB() { 
    761         if (ch2 != chPrev) { 
    762             currentState = RAND_PART_A_STATE; 
    763             count = 1; 
    764             setupRandPartA(); 
    765         } else { 
    766             count++; 
    767             if (count >= 4) { 
    768                 z = ll8[tPos]; 
    769                 tPos = tt[tPos]; 
    770                 if (rNToGo == 0) { 
    771                     rNToGo = R_NUMS[rTPos]; 
    772                     rTPos++; 
    773                     if (rTPos == 512) { 
    774                         rTPos = 0; 
    775                     } 
    776                 } 
    777                 rNToGo--; 
    778                 z ^= ((rNToGo == 1) ? 1 : 0); 
    779                 j2 = 0; 
    780                 currentState = RAND_PART_C_STATE; 
    781                 setupRandPartC(); 
    782             } else { 
    783                 currentState = RAND_PART_A_STATE; 
    784                 setupRandPartA(); 
    785             } 
    786         } 
    787     } 
    788  
    789     private void setupRandPartC() { 
    790         if (j2 < (int) z) { 
    791             currentChar = ch2; 
    792             mCrc.updateCRC(ch2); 
    793             j2++; 
    794         } else { 
    795             currentState = RAND_PART_A_STATE; 
    796             i2++; 
    797             count = 0; 
    798             setupRandPartA(); 
    799         } 
    800     } 
    801  
    802     private void setupNoRandPartB() { 
    803         if (ch2 != chPrev) { 
    804             currentState = NO_RAND_PART_A_STATE; 
    805             count = 1; 
    806             setupNoRandPartA(); 
    807         } else { 
    808             count++; 
    809             if (count >= 4) { 
    810                 z = ll8[tPos]; 
    811                 tPos = tt[tPos]; 
    812                 currentState = NO_RAND_PART_C_STATE; 
    813                 j2 = 0; 
    814                 setupNoRandPartC(); 
    815             } else { 
    816                 currentState = NO_RAND_PART_A_STATE; 
    817                 setupNoRandPartA(); 
    818             } 
    819         } 
    820     } 
    821  
    822     private void setupNoRandPartC() { 
    823         if (j2 < (int) z) { 
    824             currentChar = ch2; 
    825             mCrc.updateCRC(ch2); 
    826             j2++; 
    827         } else { 
    828             currentState = NO_RAND_PART_A_STATE; 
    829             i2++; 
    830             count = 0; 
    831             setupNoRandPartA(); 
    832         } 
    833     } 
    834  
    835     private void setDecompressStructureSizes(int newSize100k) { 
    836         if (!(0 <= newSize100k && newSize100k <= 9 && 0 <= blockSize100k 
    837                && blockSize100k <= 9)) { 
    838             // throw new IOException("Invalid block size"); 
    839         } 
    840  
    841         blockSize100k = newSize100k; 
    842  
    843         if (newSize100k == 0) { 
    844             return; 
    845         } 
    846  
    847         int n = BASE_BLOCK_SIZE * newSize100k; 
    848         ll8 = new char[n]; 
    849         tt = new int[n]; 
    850     } 
     776          } 
     777        } 
     778        rNToGo--; 
     779        z ^= ((rNToGo == 1) ? 1 : 0); 
     780        j2 = 0; 
     781        currentState = RAND_PART_C_STATE; 
     782        setupRandPartC(); 
     783      } 
     784      else { 
     785        currentState = RAND_PART_A_STATE; 
     786        setupRandPartA(); 
     787      } 
     788    } 
     789  } 
     790 
     791  private void setupRandPartC() { 
     792    if (j2 < (int) z) { 
     793      currentChar = ch2; 
     794      mCrc.updateCRC(ch2); 
     795      j2++; 
     796    } 
     797    else { 
     798      currentState = RAND_PART_A_STATE; 
     799      i2++; 
     800      count = 0; 
     801      setupRandPartA(); 
     802    } 
     803  } 
     804 
     805  private void setupNoRandPartB() { 
     806    if (ch2 != chPrev) { 
     807      currentState = NO_RAND_PART_A_STATE; 
     808      count = 1; 
     809      setupNoRandPartA(); 
     810    } 
     811    else { 
     812      count++; 
     813      if (count >= 4) { 
     814        z = ll8[tPos]; 
     815        tPos = tt[tPos]; 
     816        currentState = NO_RAND_PART_C_STATE; 
     817        j2 = 0; 
     818        setupNoRandPartC(); 
     819      } 
     820      else { 
     821        currentState = NO_RAND_PART_A_STATE; 
     822        setupNoRandPartA(); 
     823      } 
     824    } 
     825  } 
     826 
     827  private void setupNoRandPartC() { 
     828    if (j2 < (int) z) { 
     829      currentChar = ch2; 
     830      mCrc.updateCRC(ch2); 
     831      j2++; 
     832    } 
     833    else { 
     834      currentState = NO_RAND_PART_A_STATE; 
     835      i2++; 
     836      count = 0; 
     837      setupNoRandPartA(); 
     838    } 
     839  } 
     840 
     841  private void setDecompressStructureSizes(int newSize100k) { 
     842    if (!(0 <= newSize100k && newSize100k <= 9 && 0 <= blockSize100k && 
     843      blockSize100k <= 9)) 
     844    { 
     845      // throw new IOException("Invalid block size"); 
     846    } 
     847 
     848    blockSize100k = newSize100k; 
     849 
     850    if (newSize100k == 0) { 
     851      return; 
     852    } 
     853 
     854    int n = BASE_BLOCK_SIZE * newSize100k; 
     855    ll8 = new char[n]; 
     856    tt = new int[n]; 
     857  } 
    851858} 
    852859 
  • trunk/loci/formats/in/CRC.java

    r1264 r1389  
    5151 * A simple class the hold and calculate the CRC for sanity checking 
    5252 * of the data. 
    53  * 
    5453 */ 
    55 class CRC { 
    56     public static int crc32Table[] = { 
    57         0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 
    58         0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 
    59         0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 
    60         0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 
    61         0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 
    62         0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 
    63         0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 
    64         0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 
    65         0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 
    66         0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 
    67         0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 
    68         0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 
    69         0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 
    70         0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 
    71         0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 
    72         0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 
    73         0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 
    74         0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 
    75         0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 
    76         0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 
    77         0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 
    78         0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 
    79         0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 
    80         0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 
    81         0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 
    82         0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 
    83         0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 
    84         0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 
    85         0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 
    86         0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 
    87         0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 
    88         0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 
    89         0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 
    90         0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 
    91         0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 
    92         0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 
    93         0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 
    94         0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 
    95         0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 
    96         0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 
    97         0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 
    98         0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 
    99         0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 
    100         0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 
    101         0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 
    102         0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 
    103         0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 
    104         0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 
    105         0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 
    106         0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 
    107         0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 
    108         0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 
    109         0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 
    110         0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 
    111         0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 
    112         0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 
    113         0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 
    114         0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 
    115         0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 
    116         0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 
    117         0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 
    118         0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 
    119         0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 
    120         0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 
    121     }; 
     54public class CRC { 
    12255 
    123     public CRC() { 
    124         initialiseCRC(); 
     56  // -- Constants -- 
     57 
     58  public static final int[] CRC_32_TABLE = { 
     59    0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 
     60    0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 
     61    0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 
     62    0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 
     63    0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 
     64    0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 
     65    0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 
     66    0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 
     67    0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 
     68    0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 
     69    0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 
     70    0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 
     71    0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 
     72    0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 
     73    0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 
     74    0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 
     75    0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 
     76    0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 
     77    0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 
     78    0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 
     79    0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 
     80    0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 
     81    0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 
     82    0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 
     83    0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 
     84    0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 
     85    0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 
     86    0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 
     87    0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 
     88    0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 
     89    0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 
     90    0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 
     91    0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 
     92    0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 
     93    0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 
     94    0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 
     95    0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 
     96    0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 
     97    0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 
     98    0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 
     99    0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 
     100    0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 
     101    0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 
     102    0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 
     103    0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 
     104    0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 
     105    0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 
     106    0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 
     107    0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 
     108    0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 
     109    0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 
     110    0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 
     111    0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 
     112    0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 
     113    0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 
     114    0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 
     115    0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 
     116    0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 
     117    0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 
     118    0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 
     119    0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 
     120    0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 
     121    0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 
     122    0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 
     123  }; 
     124 
     125  // -- Fields -- 
     126 
     127  private int globalCrc; 
     128 
     129  // -- Constructor -- 
     130 
     131  public CRC() { 
     132    initialiseCRC(); 
     133  } 
     134 
     135  // -- CRC methods -- 
     136 
     137  public void initialiseCRC() { 
     138    globalCrc = 0xffffffff; 
     139  } 
     140 
     141  public int getFinalCRC() { 
     142    return ~globalCrc; 
     143  } 
     144 
     145  public int getGlobalCRC() { 
     146    return globalCrc; 
     147  } 
     148 
     149  public void setGlobalCRC(int newCrc) { 
     150    globalCrc = newCrc; 
     151  } 
     152 
     153  public void updateCRC(int inCh) { 
     154    int temp = (globalCrc >> 24) ^ inCh; 
     155    if (temp < 0) { 
     156      temp = 256 + temp; 
    125157    } 
     158    globalCrc = (globalCrc << 8) ^ CRC.CRC_32_TABLE[temp]; 
     159  } 
    126160 
    127     void initialiseCRC() { 
    128         globalCrc = 0xffffffff; 
    129     } 
    130  
    131     int getFinalCRC() { 
    132         return ~globalCrc; 
    133     } 
    134  
    135     int getGlobalCRC() { 
    136         return globalCrc; 
    137     } 
    138  
    139     void setGlobalCRC(int newCrc) { 
    140         globalCrc = newCrc; 
    141     } 
    142  
    143     void updateCRC(int inCh) { 
    144         int temp = (globalCrc >> 24) ^ inCh; 
    145         if (temp < 0) { 
    146             temp = 256 + temp; 
    147         } 
    148         globalCrc = (globalCrc << 8) ^ CRC.crc32Table[temp]; 
    149     } 
    150  
    151     int globalCrc; 
    152161} 
    153162 
  • trunk/loci/formats/in/DeltavisionReader.java

    r1264 r1389  
    6666  private int bytesPerPixel; 
    6767 
    68   /** Offset where the ExtHdr starts */ 
     68  /** Offset where the ExtHdr starts. */ 
    6969  protected int initExtHdrOffset = 1024; 
    7070 
     
    7272  private String order; 
    7373 
    74   /** Size of one wave, z section, or time element in the extended header */ 
     74  /** Size of one wave in the extended header. */ 
    7575  protected int wSize; 
     76 
     77  /** Size of one z section in the extended header. */ 
    7678  protected int zSize; 
     79 
     80  /** Size of one time element in the extended header. */ 
    7781  protected int tSize; 
    7882 
     
    8892  protected int numFloatsPerSection; 
    8993 
    90   /** Initialize an array of Extended Header Field structures */ 
     94  /** Initialize an array of Extended Header Field structures. */ 
    9195  protected DVExtHdrFields[][][] extHdrFields = null; 
    9296 
     
    154158  /** 
    155159   * Return a five-character string representing the dimension order 
    156    * within the file 
     160   * within the file. 
    157161   */ 
    158162  public String getDimensionOrder(String id) throws FormatException, IOException 
     
    479483   */ 
    480484  private void setOffsetInfo(int imgSequence, int numZSections, 
    481       int numWaves, int numTimes) 
     485    int numWaves, int numTimes) 
    482486  { 
    483487    int smallOffset = (numIntsPerSection + numFloatsPerSection) * 4; 
    484     switch (imgSequence) 
    485     { 
    486     // ZTW sequence 
    487     case 0: zSize = smallOffset; 
    488     tSize = zSize * numZSections; 
    489     wSize = tSize * numTimes; 
    490     break; 
    491  
    492     // WZT sequence 
    493     case 1: wSize = smallOffset; 
    494     zSize = wSize * numWaves; 
    495     tSize = zSize * numZSections; 
    496     break; 
    497  
    498     // ZWT sequence 
    499     case 2: zSize = smallOffset; 
    500     wSize = zSize * numZSections; 
    501     tSize = wSize * numWaves; 
    502     break; 
     488    switch (imgSequence) { 
     489      // ZTW sequence 
     490      case 0: 
     491        zSize = smallOffset; 
     492        tSize = zSize * numZSections; 
     493        wSize = tSize * numTimes; 
     494        break; 
     495 
     496      // WZT sequence 
     497      case 1: 
     498        wSize = smallOffset; 
     499        zSize = wSize * numWaves; 
     500        tSize = zSize * numZSections; 
     501        break; 
     502 
     503      // ZWT sequence 
     504      case 2: 
     505        zSize = smallOffset; 
     506        wSize = zSize * numZSections; 
     507        tSize = wSize * numWaves; 
     508        break; 
    503509    } 
    504510  } 
     
    506512  /** 
    507513   * Given any specific Z, W, and T of a plane, determine the totalOffset from 
    508    * the start of the extended header 
     514   * the start of the extended header. 
    509515   * @param currentZ 
    510516   * @param currentW 
     
    512518   * @return 
    513519   */ 
    514   public int getTotalOffset(int currentZ, int currentW, int currentT) 
    515   { 
     520  public int getTotalOffset(int currentZ, int currentW, int currentT) { 
    516521    return (zSize * currentZ) + (wSize * currentW) + (tSize * currentT); 
    517522  } 
     
    519524  /** 
    520525   * This method returns the a plane number from when given a Z, W 
    521    * and T offsets 
     526   * and T offsets. 
    522527   * @param currentZ 
    523528   * @param currentW 
     
    525530   * @return 
    526531   */ 
    527   public int getPlaneNumber(int currentZ, int currentW, int currentT) 
    528   { 
     532  public int getPlaneNumber(int currentZ, int currentW, int currentT) { 
    529533    int smallOffset = (numIntsPerSection + numFloatsPerSection) * 4; 
    530534    return getTotalOffset(currentZ, currentW, currentT) / smallOffset; 
  • trunk/loci/formats/in/DicomReader.java

    r1264 r1389  
    7878  protected int numImages = 0; 
    7979 
    80   /** Image width */ 
     80  /** Image width. */ 
    8181  protected int width; 
    8282 
    83   /** Image height */ 
     83  /** Image height. */ 
    8484  protected int height; 
    8585 
    86   /** Bits per pixel */ 
     86  /** Bits per pixel. */ 
    8787  protected int bitsPerPixel; 
    8888 
  • trunk/loci/formats/in/GatanReader.java

    r1264 r1389  
    5252  protected byte[] pixelData; 
    5353 
    54   /** Dimensions -- width, height, bytes per pixel */ 
     54  /** Dimensions -- width, height, bytes per pixel. */ 
    5555  protected int[] dims = new int[3]; 
    5656 
     
    116116 
    117117  /** Return true if the data is in little-endian format. */ 
    118   public boolean isLittleEndian(String id) throws FormatException, IOException 
    119   { 
     118  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    120119    if (!id.equals(currentId)) initFile(id); 
    121120    return littleEndian; 
     
    126125   * within the file. 
    127126   */ 
    128   public String getDimensionOrder(String id) throws FormatException, IOException 
     127  public String getDimensionOrder(String id) 
     128    throws FormatException, IOException 
    129129  { 
    130130    return "XYZTC"; 
  • trunk/loci/formats/in/ICSReader.java

    r1264 r1389  
    5959  /** 
    6060   * Dimensions in the following order: 
    61    * 1) bits per pixel 
    62    * 2) width 
    63    * 3) height 
    64    * 4) z 
    65    * 5) channels 
    66    * 6) timepoints 
     61   * 1) bits per pixel, 
     62   * 2) width, 
     63   * 3) height, 
     64   * 4) z, 
     65   * 5) channels, 
     66   * 6) timepoints. 
    6767   */ 
    6868  protected int[] dimensions = new int[6]; 
  • trunk/loci/formats/in/IPWReader.java

    r1264 r1389  
    4343  private static final String NO_POI_MSG = "You need to install Jakarta POI " + 
    4444    "from http://jakarta.apache.org/poi/"; 
    45  
    4645 
    4746  // -- Static fields -- 
     
    6463  } 
    6564 
    66  
    6765  // -- Fields -- 
    6866 
     
    7573  private int totalBytes= 0; 
    7674 
    77  
    7875  // -- Constructor -- 
    7976 
    8077  /** Constructs a new IPW reader. */ 
    8178  public IPWReader() { super("Image-Pro Workspace", "ipw"); } 
    82  
    8379 
    8480  // -- FormatReader API methods -- 
     
    221217  } 
    222218 
    223  
    224219  // -- Internal BaseTiffReader API methods -- 
    225220 
     
    267262    MetadataStore store = getMetadataStore(id); 
    268263 
    269     store.setPixels(null, null, sizeZ,sizeC, sizeT, null, 
     264    store.setPixels(null, null, sizeZ, sizeC, sizeT, null, 
    270265      new Boolean(!isLittleEndian(id)), getDimensionOrder(id), null); 
    271266    store.setImage(null, null, (String) metadata.get("Version"), null); 
    272267  } 
    273  
    274268 
    275269  // -- Helper methods -- 
     
    358352  } 
    359353 
    360   /** Debugging utility method */ 
     354  /** Debugging utility method. */ 
    361355  public static final void print(int depth, String s) { 
    362356    StringBuffer sb = new StringBuffer(); 
     
    366360  } 
    367361 
    368  
    369362  // -- Main method -- 
    370363 
  • trunk/loci/formats/in/ImageIOReader.java

    r1264 r1389  
    9595 
    9696  /** Return true if the data is in little-endian format. */ 
    97   public boolean isLittleEndian(String id) throws FormatException, IOException 
    98   { 
     97  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    9998    return false; 
    10099  } 
     
    104103   * within the file. 
    105104   */ 
    106   public String getDimensionOrder(String id) throws FormatException, IOException 
     105  public String getDimensionOrder(String id) 
     106    throws FormatException, IOException 
    107107  { 
    108108    return "XYCZT"; 
  • trunk/loci/formats/in/ImageJReader.java

    r1264 r1389  
    123123 
    124124  /** Return true if the data is in little-endian format. */ 
    125   public boolean isLittleEndian(String id) throws FormatException, IOException 
    126   { 
     125  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    127126    return false; 
    128127  } 
     
    132131   * within the file. 
    133132   */ 
    134   public String getDimensionOrder(String id) throws FormatException, IOException 
     133  public String getDimensionOrder(String id) 
     134    throws FormatException, IOException 
    135135  { 
    136136    return "XYCZT"; 
  • trunk/loci/formats/in/ImarisReader.java

    r1264 r1389  
    117117 
    118118  /** Return true if the data is in little-endian format. */ 
    119   public boolean isLittleEndian(String id) throws FormatException, IOException 
    120   { 
     119  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    121120    return IS_LITTLE; 
    122121  } 
     
    126125   * within the file. 
    127126   */ 
    128   public String getDimensionOrder(String id) throws FormatException, IOException 
     127  public String getDimensionOrder(String id) 
     128    throws FormatException, IOException 
    129129  { 
    130130    return "XYZCT"; 
  • trunk/loci/formats/in/LIFReader.java

    r1385 r1389  
    128128 
    129129  /** Return true if the data is in little-endian format. */ 
    130   public boolean isLittleEndian(String id) throws FormatException, IOException 
    131   { 
     130  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    132131    if (!id.equals(currentId)) initFile(id); 
    133132    return littleEndian; 
     
    138137   * within the file. 
    139138   */ 
    140   public String getDimensionOrder(String id) throws FormatException, IOException 
     139  public String getDimensionOrder(String id) 
     140    throws FormatException, IOException 
    141141  { 
    142142    int sizeZ = getSizeZ(id); 
  • trunk/loci/formats/in/LegacyPictReader.java

    r1264 r1389  
    9292 
    9393  /** Return true if the data is in little-endian format. */ 
    94   public boolean isLittleEndian(String id) throws FormatException, IOException 
    95   { 
     94  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    9695    return false; 
    9796  } 
     
    101100   * within the file. 
    102101   */ 
    103   public String getDimensionOrder(String id) throws FormatException, IOException 
     102  public String getDimensionOrder(String id) 
     103    throws FormatException, IOException 
    104104  { 
    105105    return "XYCZT"; 
  • trunk/loci/formats/in/LegacyQTReader.java

    r1264 r1389  
    109109 
    110110  /** Return true if the data is in little-endian format. */ 
    111   public boolean isLittleEndian(String id) throws FormatException, IOException 
    112   { 
     111  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    113112    return false; 
    114113  } 
     
    118117   * within the file. 
    119118   */ 
    120   public String getDimensionOrder(String id) throws FormatException, IOException 
     119  public String getDimensionOrder(String id) 
     120    throws FormatException, IOException 
    121121  { 
    122122    return "XYCZT"; 
  • trunk/loci/formats/in/LegacyZVIReader.java

    r1386 r1389  
    4848 
    4949  /** Block identifying start of useful header information. */ 
    50   private static final byte[] ZVI_MAGIC_BLOCK_1 = { // 41 00 10 
    51     65, 0, 16 
    52   }; 
     50  private static final byte[] ZVI_MAGIC_BLOCK_1 = {65, 0, 16}; // 41 00 10 
    5351 
    5452  /** Block identifying second part of useful header information. */ 
    55   private static final byte[] ZVI_MAGIC_BLOCK_2 = { // 41 00 80 
    56     65, 0, -128 
    57   }; 
     53  private static final byte[] ZVI_MAGIC_BLOCK_2 = {65, 0, -128}; // 41 00 80 
    5854 
    5955  /** Block identifying third part of useful header information. */ 
    60   private static final byte[] ZVI_MAGIC_BLOCK_3 = { // 20 00 10 
    61     32, 0, 16 
    62   }; 
     56  private static final byte[] ZVI_MAGIC_BLOCK_3 = {32, 0, 16}; // 20 00 10 
    6357 
    6458  /** Memory buffer size in bytes, for reading from disk. */ 
     
    135129 
    136130  /** Return true if the data is in little-endian format. */ 
    137   public boolean isLittleEndian(String id) throws FormatException, IOException 
    138   { 
     131  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    139132    return true; 
    140133  } 
     
    144137   * within the file. 
    145138   */ 
    146   public String getDimensionOrder(String id) throws FormatException, IOException 
     139  public String getDimensionOrder(String id) 
     140    throws FormatException, IOException 
    147141  { 
    148142    return "XYCZT"; 
     
    470464 
    471465    /** Reads in this block's image data from the given file. */ 
    472     public BufferedImage readImage(RandomAccessFile in) 
     466    public BufferedImage readImage(RandomAccessFile raf) 
    473467      throws IOException, FormatException 
    474468    { 
    475       long fileSize = in.length(); 
     469      long fileSize = raf.length(); 
    476470      if (imagePos + imageSize > fileSize) { 
    477471        throw new FormatException("File is not big enough to contain the " + 
     
    483477      // read image 
    484478      byte[] imageBytes = new byte[imageSize]; 
    485       in.seek(imagePos); 
    486       in.readFully(imageBytes); 
     479      raf.seek(imagePos); 
     480      raf.readFully(imageBytes); 
    487481 
    488482      // convert image bytes into BufferedImage 
  • trunk/loci/formats/in/LeicaReader.java

    r1364 r1389  
    219219 
    220220  /** Return true if the data is in little-endian format. */ 
    221   public boolean isLittleEndian(String id) throws FormatException, IOException 
    222   { 
     221  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    223222    if (!id.equals(currentId)) initFile(id); 
    224223    return littleEndian; 
     
    229228   * within the file. 
    230229   */ 
    231   public String getDimensionOrder(String id) throws FormatException, IOException 
     230  public String getDimensionOrder(String id) 
     231    throws FormatException, IOException 
    232232  { 
    233233    return "XYZTC"; 
     
    278278  /** Initializes the given Leica file. */ 
    279279  protected void initFile(String id) throws FormatException, IOException { 
    280     if (id.toLowerCase().endsWith("tif") || id.toLowerCase().endsWith("tiff")) 
    281     { 
     280    String idLow = id.toLowerCase(); 
     281    if (idLow.endsWith("tif") || idLow.endsWith("tiff")) { 
    282282      if (ifds == null) super.initFile(id); 
    283283 
  • trunk/loci/formats/in/MetamorphReader.java

    r1334 r1389  
    344344          break; 
    345345        case 40: 
    346           for (int i=0;i<planes;i++) { 
     346          for (int i=0; i<planes; i++) { 
    347347            num = in.readInt(); 
    348348            denom = in.readInt(); 
     
    528528    Double globalMin = (Double) metadata.get("grayMin"); 
    529529    Double globalMax = (Double) metadata.get("grayMax"); 
    530     if (globalMin != null | globalMax != null) 
    531     { 
     530    if (globalMin != null || globalMax != null) { 
    532531      getMetadataStore(currentId).setChannelGlobalMinMax(i, 
    533         globalMin,globalMax, null); 
     532        globalMin, globalMax, null); 
    534533    } 
    535534    super.setChannelGlobalMinMax(i); 
  • trunk/loci/formats/in/OIBReader.java

    r1334 r1389  
    114114 
    115115  /** Return true if the data is in little-endian format. */ 
    116   public boolean isLittleEndian(String id) throws FormatException, IOException 
    117   { 
     116  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    118117    if (!id.equals(currentId)) initFile(id); 
    119118    return littleEndian; 
     
    124123   * within the file. 
    125124   */ 
    126   public String getDimensionOrder(String id) throws FormatException, IOException 
     125  public String getDimensionOrder(String id) 
     126    throws FormatException, IOException 
    127127  { 
    128128    return "XYCTZ"; 
     
    283283 
    284284    btr.ifds = tiffIFDs; 
    285     btr.setInitialSizeZ(numImages); 
     285    btr.setSizeZ(numImages); 
    286286 
    287287    try { 
  • trunk/loci/formats/in/OIFReader.java

    r1264 r1389  
    138138 
    139139  /** Return true if the data is in little-endian format. */ 
    140   public boolean isLittleEndian(String id) throws FormatException, IOException 
    141   { 
     140  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    142141    return true; 
    143142  } 
     
    147146   * within the file. 
    148147   */ 
    149   public String getDimensionOrder(String id) throws FormatException, IOException 
     148  public String getDimensionOrder(String id) 
     149    throws FormatException, IOException 
    150150  { 
    151151    return "XYZTC"; 
  • trunk/loci/formats/in/OLEParser.java

    r1326 r1389  
    223223              } 
    224224              if (isZero) { 
    225                 if (DataTools.bytesToInt(buf, offset + 116, 4, true) < 
    226                   (in.length() / bigBlock)) { 
     225                int q = DataTools.bytesToInt(buf, offset + 116, 4, true); 
     226                if (q < in.length() / bigBlock) { 
    227227                  v.add(new Integer(baseBlock + i + 2)); 
    228228                } 
  • trunk/loci/formats/in/OMEXMLReader.java

    r1357 r1389  
    154154 
    155155  /** Return true if the data is in little-endian format. */ 
    156   public boolean isLittleEndian(String id) throws FormatException, IOException 
    157   { 
     156  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    158157    if (!id.equals(currentId)) initFile(id); 
    159158    return littleEndian; 
     
    164163   * within the file. 
    165164   */ 
    166   public String getDimensionOrder(String id) throws FormatException, IOException 
     165  public String getDimensionOrder(String id) 
     166    throws FormatException, IOException 
    167167  { 
    168168    if (!id.equals(currentId)) initFile(id); 
  • trunk/loci/formats/in/OpenlabRawReader.java

    r1264 r1389  
    118118 
    119119  /** Return true if the data is in little-endian format. */ 
    120   public boolean isLittleEndian(String id) throws FormatException, IOException 
    121   { 
     120  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    122121    return false; 
    123122  } 
     
    127126   * within the file. 
    128127   */ 
    129   public String getDimensionOrder(String id) throws FormatException, IOException 
     128  public String getDimensionOrder(String id) 
     129    throws FormatException, IOException 
    130130  { 
    131131    return "XYZTC"; 
  • trunk/loci/formats/in/OpenlabReader.java

    r1264 r1389  
    139139 
    140140  /** Return true if the data is in little-endian format. */ 
    141   public boolean isLittleEndian(String id) throws FormatException, IOException 
    142   { 
     141  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    143142    if (!id.equals(currentId)) initFile(id); 
    144143    return little; 
     
    264263      // Read info from the iPic comment. This serves as a 
    265264      // starting point to read the rest. 
    266       temp = new byte[] { b[pos], b[pos+1], b[pos+2], b[pos+3] }; 
     265      temp = new byte[] {b[pos], b[pos+1], b[pos+2], b[pos+3]}; 
    267266      num = batoi(temp); 
    268267      if (num != expectedBlock) { 
     
    270269      } 
    271270      expectedBlock++; 
    272       temp = new byte[] { b[pos+4], b[pos+5], b[pos+6], b[pos+7] }; 
     271      temp = new byte[] {b[pos+4], b[pos+5], b[pos+6], b[pos+7]}; 
    273272      if (totalBlocks == -1) { 
    274273        totalBlocks = batoi(temp); 
     
    282281      // skip to size 
    283282      pos += 16; 
    284       temp = new byte[] { b[pos], b[pos+1], b[pos+2], b[pos+3] }; 
     283      temp = new byte[] {b[pos], b[pos+1], b[pos+2], b[pos+3]}; 
    285284      size = batoi(temp); 
    286285      pos += 8; 
     
    459458        in.skipBytes(2); 
    460459 
    461         if (isOpenlab2 == true) { 
     460        if (isOpenlab2) { 
    462461          byte[] layerName = new byte[127]; 
    463462          in.read(layerName); 
     
    547546    int total = 0; 
    548547    for (int i = 0; i < len; i++) { 
    549       total += (inp[i]<0?256+inp[i]:(int)inp[i]) << (((len - 1) - i) * 8); 
     548      total += (inp[i]<0 ? 256+inp[i] : (int) inp[i]) << (((len - 1) - i) * 8); 
    550549    } 
    551550    return total; 
     
    553552 
    554553  /** 
    555    * Checks which type of Openlab file this is: 
    556    * 1 => all planes are greyscale 
    557    * 2 => all planes are RGB 
    558    * 3 => every 4th plane is RGB, remaining planes are greyscale 
     554   * Checks which type of Openlab file this is. 
     555   * 1 =&gt; all planes are greyscale. 
     556   * 2 =&gt; all planes are RGB. 
     557   * 3 =&gt; every 4th plane is RGB, remaining planes are greyscale. 
    559558   */ 
    560559  private int checkType() throws FormatException, IOException { 
  • trunk/loci/formats/in/PerkinElmerReader.java

    r1264 r1389  
    123123 
    124124  /** Return true if the data is in little-endian format. */ 
    125   public boolean isLittleEndian(String id) throws FormatException, IOException 
    126   { 
     125  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    127126    if (!id.equals(currentId)) initFile(id); 
    128127    return tiff.isLittleEndian(files[0]); 
     
    133132   * within the file. 
    134133   */ 
    135   public String getDimensionOrder(String id) throws FormatException, IOException 
     134  public String getDimensionOrder(String id) 
     135    throws FormatException, IOException 
    136136  { 
    137137    return "XYCTZ"; 
     
    286286      while (t.hasMoreTokens()) { 
    287287        if (tNum < 7) { t.nextToken(); } 
    288         else if ((tNum > 7 && tNum < 12) || (tNum > 12 && tNum < 18) || 
    289           (tNum > 18 && tNum < 22)) { 
     288        else if ((tNum > 7 && tNum < 12) || 
     289          (tNum > 12 && tNum < 18) || (tNum > 18 && tNum < 22)) 
     290        { 
    290291          t.nextToken(); 
    291292        } 
  • trunk/loci/formats/in/PictReader.java

    r1264 r1389  
    172172 
    173173  /** Return true if the data is in little-endian format. */ 
    174   public boolean isLittleEndian(String id) throws FormatException, IOException 
    175   { 
     174  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    176175    if (!id.equals(currentId)) initFile(id); 
    177176    return little; 
     
    182181   * within the file. 
    183182   */ 
    184   public String getDimensionOrder(String id) throws FormatException, IOException 
     183  public String getDimensionOrder(String id) 
     184    throws FormatException, IOException 
    185185  { 
    186186    return "XYCZT"; 
     
    265265    // handles case when we call this method directly, instead of 
    266266    // through initFile(String) 
    267     if (DEBUG) System.out.println("PictReader.openBytes"); 
     267    if (DEBUG) System.out.println("PictReader.open"); 
    268268 
    269269    strips = new Vector(); 
     
    275275 
    276276    try { 
    277       while (driveDecoder()); 
    278     } 
    279     catch (Exception e) { 
     277      while (driveDecoder()) { } 
     278    } 
     279    catch (FormatException e) { 
    280280      e.printStackTrace(); 
    281281      return ImageTools.makeBuffered(qtTools.pictToImage(pix)); 
     
    540540        System.arraycopy(bytes, pt, buf, 0, rowBytes); 
    541541 
    542         for (int j=buf.length; --j >= 0; ) { 
     542        for (int j=buf.length; --j >= 0;) { 
    543543          buf[j] = (byte) ~buf[j]; 
    544544        } 
     
    678678    pt += 18; 
    679679 
    680     if (opcode == PICT_BITSRGN || opcode == PICT_PACKBITSRGN) { 
    681       pt += 2; 
    682     } 
     680    if (opcode == PICT_BITSRGN || opcode == PICT_PACKBITSRGN) pt += 2; 
    683681 
    684682    handlePixmap(rowBytes, pixelSize, compCount); 
     
    686684 
    687685  /** Handles the unpacking of the image data. */ 
    688   private void handlePixmap(int rowBytes, int pixelSize, int compCount) 
     686  private void handlePixmap(int rBytes, int pixelSize, int compCount) 
    689687    throws FormatException 
    690688  { 
    691689    if (DEBUG) { 
    692690      System.out.println("PictReader.handlePixmap(" + 
    693         rowBytes + ", " + pixelSize + ", " + compCount + ")"); 
     691        rBytes + ", " + pixelSize + ", " + compCount + ")"); 
    694692    } 
    695693    int rawLen; 
     
    701699    byte[] outBuf = null;  // used to expand pixel data 
    702700 
    703     boolean compressed = (rowBytes >= 8) || (pixelSize == 32); 
    704  
    705     bufSize = rowBytes; 
     701    boolean compressed = (rBytes >= 8) || (pixelSize == 32); 
     702 
     703    bufSize = rBytes; 
    706704 
    707705    outBufSize = width; 
     
    733731      buf = new byte[bufSize]; 
    734732      for (int row=0; row<height; row++) { 
    735         System.arraycopy(bytes, pt, buf, 0, rowBytes); 
     733        System.arraycopy(bytes, pt, buf, 0, rBytes); 
    736734 
    737735        switch (pixelSize) { 
     
    758756      buf = new byte[bufSize + 1 + bufSize / 128]; 
    759757      for (int row=0; row<height; row++) { 
    760         if (rowBytes > 250) { 
     758        if (rBytes > 250) { 
    761759          rawLen = DataTools.bytesToInt(bytes, pt, 2, little); 
    762760          pt += 2; 
     
    827825 
    828826  /** Expand an array of bytes. */ 
    829   private void expandPixels(int bitSize, byte[] in, byte[] out, int outLen) 
     827  private void expandPixels(int bitSize, byte[] ib, byte[] ob, int outLen) 
    830828    throws FormatException 
    831829  { 
    832830    if (DEBUG) { 
    833831      System.out.println("PictReader.expandPixels(" + bitSize + ", " + 
    834         in.length + ", " + out.length + ", " + outLen + ")"); 
     832        ib.length + ", " + ob.length + ", " + outLen + ")"); 
    835833    } 
    836834    if (bitSize == 1) { 
     
    838836      int max = outLen / 8; 
    839837      for (int i=0; i<max; i++) { 
    840         if (i < in.length) { 
    841           int look = (in[i] & 0xff) * 8; 
    842           System.arraycopy(EXPANSION_TABLE, look, out, i*8, 8); 
     838        if (i < ib.length) { 
     839          int look = (ib[i] & 0xff) * 8; 
     840          System.arraycopy(EXPANSION_TABLE, look, ob, i*8, 8); 
    843841        } 
    844842        else i = max; 
     
    846844 
    847845      if (remainder != 0) { 
    848         if (max < in.length) { 
    849           System.arraycopy(EXPANSION_TABLE, (in[max] & 0xff) * 8, out, 
     846        if (max < ib.length) { 
     847          System.arraycopy(EXPANSION_TABLE, (ib[max] & 0xff) * 8, ob, 
    850848            max*8, remainder); 
    851849        } 
     
    871869    } 
    872870 
    873     switch (bitSize) 
    874     { 
     871    switch (bitSize) { 
    875872      case 1: 
    876873        mask = 0x80; 
     
    897894 
    898895    i = 0; 
    899     for (o = 0; o < out.length;) { 
     896    for (o = 0; o < ob.length;) { 
    900897      tmask = mask; 
    901898      tpixelshift = pixelshift; 
    902       v = in[i]; 
    903       for (t = 0; t < count && o < out.length; ++t, ++o) { 
    904         out[o] = (byte) (((v & tmask) >>> tpixelshift) & 0xff); 
     899      v = ib[i]; 
     900      for (t = 0; t < count && o < ob.length; ++t, ++o) { 
     901        ob[o] = (byte) (((v & tmask) >>> tpixelshift) & 0xff); 
    905902        tmask = (byte) ((tmask & 0xff) >>> maskshift); 
    906903        tpixelshift -= pixelshiftdelta; 
     
    911908 
    912909  /** PackBits variant that outputs an int array. */ 
    913   private void unpackBits(byte[] in, int[] out) { 
     910  private void unpackBits(byte[] ib, int[] ob) { 
    914911    if (DEBUG) { 
    915       System.out.println("PictReader.unpackBits(" + in + ", " + out + ")"); 
     912      System.out.println("PictReader.unpackBits(" + ib + ", " + ob + ")"); 
    916913    } 
    917914    int i = 0; 
     
    921918    int end; 
    922919 
    923     for (o=0; o<out.length;) { 
    924       if ((i+1) < in.length) { 
    925         b = in[i++]; 
     920    for (o=0; o<ob.length;) { 
     921      if (i+1 < ib.length) { 
     922        b = ib[i++]; 
    926923        if (b >= 0) { 
    927924          b++; 
    928925          end = o + b; 
    929926          for(; o < end; o++, i+=2) { 
    930             if ((o < out.length) && ((i+1) < in.length)) { 
    931               out[o] = (((in[i] & 0xff) << 8) + (in[i+1] & 0xff)) & 0xffff; 
     927            if (o < ob.length && (i+1) < ib.length) { 
     928              ob[o] = (((ib[i] & 0xff) << 8) + (ib[i+1] & 0xff)) & 0xffff; 
    932929            } 
    933930            else o = end; 
     
    935932        } 
    936933        else if (b != -128) { 
    937           rep = (((in[i] & 0xff) << 8) + (in[i+1] & 0xff)) & 0xffff; 
     934          rep = (((ib[i] & 0xff) << 8) + (ib[i+1] & 0xff)) & 0xffff; 
    938935          i += 2; 
    939936          end = o - b + 1; 
    940937          for (; o < end; o++) { 
    941             if (o < out.length) { 
    942               out[o] = rep; 
    943             } 
     938            if (o < ob.length) ob[o] = rep; 
    944939            else o = end; 
    945940          } 
    946941        } 
    947942      } 
    948       else o = out.length; 
     943      else o = ob.length; 
    949944    } 
    950945  } 
  • trunk/loci/formats/in/Plane2D.java

    r1334 r1389  
    3333 * @author Chris Allan callan at blackcat.ca 
    3434 */ 
    35 public class Plane2D 
    36 { 
     35public class Plane2D { 
     36 
    3737  /** Contains the plane data. */ 
    3838  private ByteBuffer    data; 
     
    9797   */ 
    9898  Plane2D(ByteBuffer data, int type, boolean isLittleEndian, 
    99           int sizeX, int sizeY) 
     99    int sizeX, int sizeY) 
    100100  { 
    101101    this.type = type; 
     
    139139   * @return The intensity value. 
    140140   */ 
    141   public double getPixelValue(int x, int y) 
    142   { 
     141  public double getPixelValue(int x, int y) { 
    143142    int offset = ((sizeX * y) + x) * bytesPerPixel; 
    144143 
     
    170169   * @return type enumeration value for use with class constants. 
    171170   */ 
    172   public static int typeFromString(String typeAsString) 
    173   { 
     171  public static int typeFromString(String typeAsString) { 
    174172    String uppercaseTypeAsString = typeAsString.toUpperCase(); 
    175     for (int i = 0; i < pixelsTypes.length; i++) 
    176     { 
     173    for (int i = 0; i < pixelsTypes.length; i++) { 
    177174      if (pixelsTypes[i].equals(uppercaseTypeAsString)) 
    178175        return i; 
     
    180177    throw new RuntimeException("Unknown type: '" + typeAsString + "'"); 
    181178  } 
     179 
    182180} 
  • trunk/loci/formats/in/QTReader.java

    r1334 r1389  
    294294 
    295295  /** Return true if the data is in little-endian format. */ 
    296   public boolean isLittleEndian(String id) throws FormatException, IOException 
    297   { 
     296  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    298297    if (!id.equals(currentId)) initFile(id); 
    299298    return little; 
     
    304303   * within the file. 
    305304   */ 
    306   public String getDimensionOrder(String id) throws FormatException, IOException 
     305  public String getDimensionOrder(String id) 
     306    throws FormatException, IOException 
    307307  { 
    308308    return "XYCZT"; 
  • trunk/loci/formats/in/RedBlackTreeNode.java

    r1264 r1389  
    3535 
    3636  /** Pointer to the parent node. */ 
    37   public RedBlackTreeNode parent; 
     37  protected RedBlackTreeNode parent; 
    3838 
    3939  /** Vector of pointers to the child nodes. */ 
    40   public Vector children; 
     40  protected Vector children; 
    4141 
    4242  /** True if this node is the rightmost in its level. */ 
    43   public boolean isLast; 
     43  protected boolean isLast; 
    4444 
    4545  /** Depth of the node (from the root). */ 
    46   public int depth; 
     46  protected int depth; 
    4747 
    4848  /** Node type. */ 
  • trunk/loci/formats/in/SDTReader.java

    r1264 r1389  
    114114 
    115115  /** Return true if the data is in little-endian format. */ 
    116   public boolean isLittleEndian(String id) throws FormatException, IOException 
    117   { 
     116  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    118117    return true; 
    119118  } 
     
    123122   * within the file. 
    124123   */ 
    125   public String getDimensionOrder(String id) throws FormatException, IOException 
     124  public String getDimensionOrder(String id) 
     125    throws FormatException, IOException 
    126126  { 
    127127    return "XYZTC"; 
  • trunk/loci/formats/in/TiffReader.java

    r1264 r1389  
    6565   * {@link MetadataStore#setPixels()}. 
    6666   */ 
    67   protected void setInitialSizeZ(int sizeZ) { this.sizeZ = sizeZ; } 
     67  protected void setSizeZ(int sizeZ) { this.sizeZ = sizeZ; } 
    6868 
    6969  // -- Internal BaseTiffReader API methods -- 
     
    112112 
    113113    String comment = (String) metadata.get("Comment"); 
    114     if (store instanceof OMEXMLMetadataStore 
    115       && comment != null && comment.indexOf("ome.xsd") >= 0) 
     114    if (store instanceof OMEXMLMetadataStore && 
     115      comment != null && comment.indexOf("ome.xsd") >= 0) 
    116116    { 
    117117      OMEXMLMetadataStore xmlStore = (OMEXMLMetadataStore) store; 
  • trunk/loci/formats/in/ZeissZVIReader.java

    r1386 r1389  
    132132 
    133133  /** Return true if the data is in little-endian format. */ 
    134   public boolean isLittleEndian(String id) throws FormatException, IOException 
    135   { 
     134  public boolean isLittleEndian(String id) throws FormatException, IOException { 
    136135    return true; 
    137136  } 
     
    371370 
    372371      try { 
    373         if (((isContents && 
    374           ((pathName.indexOf("Item") != -1) || pathName.indexOf("Image") != -1) 
    375           && data.length > 6000)) || (data.length == dataLength)) 
     372        if ((isContents && (pathName.indexOf("Item") != -1 || 
     373          pathName.indexOf("Image") != -1) && data.length > 6000) || 
     374          data.length == dataLength) 
    376375        { 
    377376          header = data; 
    378377 
    379           while ((dataLength != 0) && (data.length < dataLength) && isContents 
    380             && ((pathName.indexOf("Item") != -1) || 
    381             pathName.indexOf("Image") != -1)) 
     378          while (dataLength != 0 && data.length < dataLength && isContents && 
     379            (pathName.indexOf("Item") != -1 || pathName.indexOf("Image") != -1)) 
    382380          { 
    383381            i++; 
     
    511509                  System.arraycopy(chunkOne, k*bpp*imageWidth, tct, 
    512510                    (k+1)*bpp*imageWidth - mul, mul); 
    513                   System.arraycopy(chunkOne, k*bpp*imageWidth+mul, tct, 
    514                     k*bpp*imageWidth, bpp*imageWidth - mul); 
     511                  System.arraycopy(chunkOne, k * bpp * imageWidth + mul, tct, 
     512                    k * bpp * imageWidth, bpp * imageWidth - mul); 
    515513                } 
    516514 
     
    524522                  System.arraycopy(chunkTwo, k*bpp*imageWidth, tco, 
    525523                    (k+1)*bpp*imageWidth - mul, mul); 
    526                   System.arraycopy(chunkTwo, k*bpp*imageWidth+mul, tco, 
    527                     k*bpp*imageWidth, bpp*imageWidth - mul); 
     524                  System.arraycopy(chunkTwo, k * bpp * imageWidth + mul, tco, 
     525                    k * bpp * imageWidth, bpp * imageWidth - mul); 
    528526                } 
    529527 
     
    546544                    (k+1)*bpp*imageWidth - mul, mul); 
    547545                  System.arraycopy(px, k*bpp*imageWidth+mul, tmp, 
    548                     k*bpp*imageWidth, bpp*imageWidth - mul); 
     546                    k * bpp * imageWidth, bpp*imageWidth - mul); 
    549547                } 
    550548 
     
    928926            case 1538: metadata.put("Author", data); break; 
    929927            case 1539: metadata.put("Keywords", data); break; 
    930             case 1540: metadata.put("Comments", data);break; 
     928            case 1540: metadata.put("Comments", data); break; 
    931929            case 1541: metadata.put("SampleID", data); break; 
    932930            case 1542: metadata.put("Subject", data); break; 
     
    941939            case 1551: metadata.put("File Size", data); break; 
    942940            case 1553: metadata.put("Filename", data); break; 
    943             case 1792: metadata.put("ProjectGroup", data);break; 
     941            case 1792: metadata.put("ProjectGroup", data); break; 
    944942            case 1793: metadata.put("Acquisition Date", data); break; 
    945943            case 1794: metadata.put("Last modified by", data); break; 
     
    977975            case 2071: metadata.put("tag_ID_2071", data); break; 
    978976            case 2072: metadata.put("Focus Position", data); break; 
    979             case 2073: metadata.put("Stage Position X", data);break; 
     977            case 2073: metadata.put("Stage Position X", data); break; 
    980978            case 2074: metadata.put("Stage Position Y", data); break; 
    981979            case 2075: 
     
    14411439    Integer sizeT = null; 
    14421440 
    1443     try { 
    1444       sizeT = new Integer(getImageCount(currentId)); 
    1445     } catch (Exception e) { 
     1441    try { sizeT = new Integer(getImageCount(currentId)); } 
     1442    catch (Exception e) { 
    14461443      // FIXME: Eat the exception for now, we should do something productive 
    14471444      // here as the image metadata really is useless without a valid sizeT. 
  • trunk/loci/formats/out/AVIWriter.java

    r1264 r1389  
    463463      idx1Pos = raFile.getFilePointer(); 
    464464      raFile.seek(saveLIST2Size); 
    465       DataTools.writeInt(raFile, (int)(idx1Pos - (saveLIST2Size + 4)), true); 
     465      DataTools.writeInt(raFile, (int) (idx1Pos - (saveLIST2Size + 4)), true); 
    466466      raFile.seek(idx1Pos); 
    467467      DataTools.writeString(raFile, "idx1"); 
     
    499499      endPos = raFile.getFilePointer(); 
    500500      raFile.seek(saveFileSize); 
    501       DataTools.writeInt(raFile, (int)(endPos - (saveFileSize+4)), true); 
     501      DataTools.writeInt(raFile, (int) (endPos - (saveFileSize + 4)), true); 
    502502 
    503503      raFile.seek(saveidx1Length); 
Note: See TracChangeset for help on using the changeset viewer.