Changeset 4681


Ignore:
Timestamp:
12/09/08 08:11:12 (11 years ago)
Author:
melissa
Message:

Modified Codec API to be a little more intuitive. The compress and decompress methods of each codec now accept a loci.formats.codec.CodecOptions parameter, instead of an arbitrary Object.

Location:
trunk/components/bio-formats/src/loci/formats
Files:
3 added
30 edited

Legend:

Unmodified
Added
Removed
  • trunk/components/bio-formats/src/loci/formats/FormatReader.java

    r4590 r4681  
    253253    byte[] buf) throws IOException 
    254254  { 
    255     int c = getSizeC(); 
     255    int c = getRGBChannelCount(); 
    256256    int bpp = FormatTools.getBytesPerPixel(getPixelType()); 
    257257    if (x == 0 && y == 0 && w == getSizeX() && h == getSizeY()) { 
  • trunk/components/bio-formats/src/loci/formats/TiffTools.java

    r4645 r4681  
    12931293    } 
    12941294 
     1295    CodecOptions options = new CodecOptions(); 
     1296    options.interleaved = true; 
     1297    options.littleEndian = littleEndian; 
     1298 
    12951299    if (isTiled) { 
    12961300      long tileWidth = getIFDLongValue(ifd, TILE_WIDTH, true, 0); 
     
    13251329 
    13261330          int size = (int) (tileWidth * tileLength * pixel * channels); 
     1331          options.maxBytes = size; 
    13271332          if (jpegTable != null) { 
    13281333            byte[] q = new byte[jpegTable.length + tile.length - 4]; 
    13291334            System.arraycopy(jpegTable, 0, q, 0, jpegTable.length - 2); 
    13301335            System.arraycopy(tile, 2, q, jpegTable.length - 2, tile.length - 2); 
    1331             tile = uncompress(q, compression, size); 
    1332           } 
    1333           else tile = uncompress(tile, compression, size); 
     1336            tile = uncompress(q, compression, options); 
     1337          } 
     1338          else tile = uncompress(tile, compression, options); 
    13341339 
    13351340          undifference(tile, bitsPerSample, tileWidth, planarConfig, predictor, 
     
    14051410          byte[] bytes = new byte[(int) stripByteCounts[strip]]; 
    14061411          in.read(bytes); 
     1412          options.maxBytes = size; 
    14071413          if (jpegTable != null) { 
    14081414            byte[] q = new byte[jpegTable.length + bytes.length - 4]; 
     
    14101416            System.arraycopy(bytes, 2, q, jpegTable.length - 2, 
    14111417              bytes.length - 2); 
    1412             bytes = uncompress(q, compression, size); 
    1413           } 
    1414           else bytes = uncompress(bytes, compression, size); 
     1418            bytes = uncompress(q, compression, options); 
     1419          } 
     1420          else bytes = uncompress(bytes, compression, options); 
    14151421 
    14161422          undifference(bytes, bitsPerSample, 
     
    17181724 
    17191725  /** Decodes a strip of data compressed with the given compression scheme. */ 
    1720   public static byte[] uncompress(byte[] input, int compression, int size) 
     1726  public static byte[] uncompress(byte[] input, int compression, 
     1727    CodecOptions options) 
    17211728    throws FormatException, IOException 
    17221729  { 
     
    17381745    } 
    17391746    else if (compression == LZW) { 
    1740       return new LZWCodec().decompress(input, new Integer(size)); 
     1747      return new LZWCodec().decompress(input, options); 
    17411748    } 
    17421749    else if (compression == JPEG || compression == ALT_JPEG) { 
    1743       return new JPEGCodec().decompress(input, 
    1744         new Object[] {Boolean.TRUE, Boolean.TRUE}); 
     1750      return new JPEGCodec().decompress(input, options); 
    17451751    } 
    17461752    else if (compression == JPEG_2000) { 
    1747       return new JPEG2000Codec().decompress(input, 
    1748         new Object[] {Boolean.TRUE, Boolean.TRUE, new Long(size)}); 
     1753      return new JPEG2000Codec().decompress(input, options); 
    17491754    } 
    17501755    else if (compression == PACK_BITS) { 
    1751       return new PackbitsCodec().decompress(input, new Integer(size)); 
     1756      return new PackbitsCodec().decompress(input, options); 
    17521757    } 
    17531758    else if (compression == PROPRIETARY_DEFLATE || compression == DEFLATE) { 
    1754       return new ZlibCodec().decompress(input); 
     1759      return new ZlibCodec().decompress(input, options); 
    17551760    } 
    17561761    else if (compression == THUNDERSCAN) { 
     
    17591764    } 
    17601765    else if (compression == NIKON) { 
    1761       return new NikonCodec().decompress(input, new Integer(size)); 
     1766      return new NikonCodec().decompress(input, options); 
    17621767    } 
    17631768    else if (compression == LURAWAVE) { 
    1764       return new LuraWaveCodec().decompress(input, new Integer(size)); 
     1769      return new LuraWaveCodec().decompress(input, options); 
    17651770    } 
    17661771    else { 
     
    25222527  { 
    25232528    int compression = getIFDIntValue(ifd, COMPRESSION, false, UNCOMPRESSED); 
    2524     int width =(int) getImageWidth(ifd); 
    2525     int height =(int) getImageLength(ifd); 
    2526     int bytes = (int) Math.floor((double) 
    2527       ((int[]) getIFDValue(ifd, BITS_PER_SAMPLE))[0] / 8.0); 
    2528     int[] dims = {getIFDIntValue(ifd, SAMPLES_PER_PIXEL, false, 1), bytes}; 
    2529     // TODO: Change the decompression to use littleEndian 
    2530     Object[] options = {Boolean.TRUE, Boolean.TRUE}; 
     2529 
     2530    CodecOptions options = new CodecOptions(); 
     2531    options.width = (int) getImageWidth(ifd); 
     2532    options.height = (int) getImageLength(ifd); 
     2533    options.bitsPerSample = getBitsPerSample(ifd)[0]; 
     2534    options.channels = getSamplesPerPixel(ifd); 
     2535    options.littleEndian = isLittleEndian(ifd); 
     2536    options.interleaved = true; 
     2537 
    25312538    if (compression == UNCOMPRESSED) return input; 
    25322539    else if (compression == JPEG) { 
    2533       return new JPEGCodec().compress(input, width, height, dims, options); 
     2540      return new JPEGCodec().compress(input, options); 
    25342541    } 
    25352542    else if (compression == JPEG_2000) { 
    2536       return new JPEG2000Codec().compress(input, width, height, dims, options); 
     2543      return new JPEG2000Codec().compress(input, options); 
    25372544    } 
    25382545    else { 
     
    25612568    else if (compression == LZW) { 
    25622569      LZWCodec c = new LZWCodec(); 
    2563       return c.compress(input, 0, 0, null, null); 
     2570      return c.compress(input, null); 
    25642571      // return Compression.lzwCompress(input); 
    25652572    } 
  • trunk/components/bio-formats/src/loci/formats/codec/Base64Codec.java

    r4521 r4681  
    3939 * @author Melissa Linkert linkert at wisc.edu 
    4040 */ 
    41 public class Base64Codec extends BaseCodec implements Codec { 
     41public class Base64Codec extends BaseCodec { 
    4242 
    4343  // Base64 alphabet and codes 
     
    7272  } 
    7373 
    74   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    75   public byte[] compress(byte[] input, int x, int y, int[] dims, 
    76     Object options) throws FormatException 
     74  /* @see Codec#compress(byte[], CodecOptions) */ 
     75  public byte[] compress(byte[] input, CodecOptions options) 
     76    throws FormatException 
    7777  { 
    7878    int dataBits = input.length * 8; 
     
    147147  } 
    148148 
    149   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    150   public byte[] decompress(RandomAccessStream in, Object options) 
     149  /* @see Codec#decompress(RandomAccessStream, CodecOptions) */ 
     150  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    151151    throws FormatException, IOException 
    152152  { 
  • trunk/components/bio-formats/src/loci/formats/codec/BaseCodec.java

    r4521 r4681  
    6464    r.nextBytes(testdata); 
    6565    LogTools.println("Compressing data"); 
    66     byte[] compressed = compress(testdata, 0, 0, null, null); 
     66    byte[] compressed = compress(testdata, null); 
    6767    LogTools.println("Compressed size: " + compressed.length); 
    6868    LogTools.println("Decompressing data"); 
     
    9494      System.arraycopy(testdata, 500*i, twoDtest[i], 0, 500); 
    9595    } 
    96     byte[] twoDcompressed = compress(twoDtest, 0, 0, null, null); 
     96    byte[] twoDcompressed = compress(twoDtest, null); 
    9797    LogTools.print("Comparing compressed data... "); 
    9898    if (twoDcompressed.length != compressed.length) { 
     
    125125   * 
    126126   * @param data The data to be compressed. 
    127    * @param x Length of the x dimension of the image data, if appropriate. 
    128    * @param y Length of the y dimension of the image data, if appropriate. 
    129    * @param dims The dimensions of the image data, if appropriate. 
    130127   * @param options Options to be used during compression, if appropriate. 
    131128   * @return The compressed data. 
     
    133130   *   appropriate type. 
    134131   */ 
    135   public byte[] compress(byte[][] data, int x, int y, 
    136     int[] dims, Object options) throws FormatException 
     132  public byte[] compress(byte[][] data, CodecOptions options) 
     133    throws FormatException 
    137134  { 
    138135    int len = 0; 
     
    146143      curPos += data[i].length; 
    147144    } 
    148     return compress(toCompress, x, y, dims, options); 
     145    return compress(toCompress, options); 
    149146  } 
    150147 
     
    159156  } 
    160157 
    161   /* @see Codec#decompress(byte[], Object) */ 
    162   //public abstract byte[] decompress(byte[] data, Object options) 
    163   //  throws FormatException; 
    164   public byte[] decompress(byte[] data, Object options) 
     158  /* @see Codec#decompress(byte[], CodecOptions) */ 
     159  public byte[] decompress(byte[] data, CodecOptions options) 
    165160    throws FormatException 
    166161  { 
     
    176171  } 
    177172 
    178   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    179   //public byte[] decompress(RandomAccessStream in, Object options) 
    180   //  throws FormatException 
    181   //{ 
    182   //  try { 
    183   //    byte[] b = new byte[(int) in.length()]; 
    184   //    in.read(b); 
    185   //    return decompress(b, options); 
    186   //  } 
    187   //  catch (IOException exc) { throw new FormatException(exc); } 
    188   //} 
    189   public abstract byte[] decompress(RandomAccessStream in, Object options) 
     173  /* @see Codec#decompress(RandomAccessStream, CodecOptions) */ 
     174  public abstract byte[] decompress(RandomAccessStream in, CodecOptions options) 
    190175    throws FormatException, IOException; 
    191176 
     
    200185   *   appropriate type. 
    201186   */ 
    202   public byte[] decompress(byte[][] data, Object options) 
     187  public byte[] decompress(byte[][] data, CodecOptions options) 
    203188    throws FormatException 
    204189  { 
  • trunk/components/bio-formats/src/loci/formats/codec/Codec.java

    r4521 r4681  
    5555   * 
    5656   * @param data The data to be compressed. 
    57    * @param x Length of the x dimension of the image data, if appropriate. 
    58    * @param y Length of the y dimension of the image data, if appropriate. 
    59    * @param dims The dimensions of the image data, if appropriate. 
    6057   * @param options Options to be used during compression, if appropriate. 
    6158   * @return The compressed data. 
     
    6360   *   appropriate type. 
    6461   */ 
    65   byte[] compress(byte[] data, int x, int y, 
    66       int[] dims, Object options) throws FormatException; 
     62  byte[] compress(byte[] data, CodecOptions options) throws FormatException; 
    6763 
    6864  /** 
     
    7066   * 
    7167   * @param data The data to be compressed. 
    72    * @param x Length of the x dimension of the image data, if appropriate. 
    73    * @param y Length of the y dimension of the image data, if appropriate. 
    74    * @param dims The dimensions of the image data, if appropriate. 
    7568   * @param options Options to be used during compression, if appropriate. 
    7669   * @return The compressed data. 
     
    7871   *   appropriate type. 
    7972   */ 
    80   byte[] compress(byte[][] data, int x, int y, 
    81       int[] dims, Object options) throws FormatException; 
     73  byte[] compress(byte[][] data, CodecOptions options) throws FormatException; 
    8274 
    8375  /** 
     
    8981   * @throws FormatException If data is not valid. 
    9082   */ 
    91   byte[] decompress(byte[] data, Object options) throws FormatException; 
     83  byte[] decompress(byte[] data, CodecOptions options) throws FormatException; 
    9284 
    9385  /** 
     
    9991   * @throws FormatException If data is not valid. 
    10092   */ 
    101   byte[] decompress(byte[][] data, Object options) throws FormatException; 
     93  byte[] decompress(byte[][] data, CodecOptions options) throws FormatException; 
    10294 
    10395  /** 
     
    130122   *   decompressor. 
    131123   */ 
    132   byte[] decompress(RandomAccessStream in, Object options) 
     124  byte[] decompress(RandomAccessStream in, CodecOptions options) 
    133125    throws FormatException, IOException; 
    134126 
  • trunk/components/bio-formats/src/loci/formats/codec/JPEG2000Codec.java

    r4645 r4681  
    4343 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/formats/codec/JPEGCodec.java">SVN</a></dd></dl> 
    4444 */ 
    45 public class JPEG2000Codec extends BaseCodec implements Codec { 
     45public class JPEG2000Codec extends BaseCodec { 
    4646 
    4747  // -- Constants -- 
     
    142142  // -- Codec API methods -- 
    143143 
    144   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    145   public byte[] compress(byte[] data, int x, int y, int[] dims, Object options) 
     144  /** 
     145   * The CodecOptions parameter should have the following fields set: 
     146   *  {@link CodecOptions#width width} 
     147   *  {@link CodecOptions#height height} 
     148   *  {@link CodecOptions#bitsPerSample bitsPerSample} 
     149   *  {@link CodecOptions#channels channels} 
     150   *  {@link CodecOptions#interleaved interleaved} 
     151   *  {@link CodecOptions#littleEndian littleEndian} 
     152   * 
     153   * @see Codec#compress(byte[], CodecOptions) 
     154   */ 
     155  public byte[] compress(byte[] data, CodecOptions options) 
    146156    throws FormatException 
    147157  { 
    148     boolean littleEndian = false, interleaved = false; 
    149     if (options instanceof Boolean) { 
    150       littleEndian = ((Boolean) options).booleanValue(); 
    151     } 
    152     else { 
    153       Object[] o = (Object[]) options; 
    154       littleEndian = ((Boolean) o[0]).booleanValue(); 
    155       interleaved = ((Boolean) o[1]).booleanValue(); 
    156     } 
     158    if (options == null) options = CodecOptions.getDefaultOptions(); 
    157159 
    158160    ByteArrayOutputStream out = new ByteArrayOutputStream(); 
    159  
    160161    BufferedImage img = null; 
    161162 
     
    169170    // channels for a specific pixel). 
    170171 
    171     if (dims[1] == 1) { 
    172       byte[][] b = new byte[dims[0]][x * y]; 
    173       if (interleaved) { 
    174         for (int q=0; q<x*y; q++) { 
    175           for (int c=0; c<dims[0]; c++) { 
     172    int plane = options.width * options.height; 
     173 
     174    if (options.bitsPerSample == 8) { 
     175      byte[][] b = new byte[options.channels][plane]; 
     176      if (options.interleaved) { 
     177        for (int q=0; q<plane; q++) { 
     178          for (int c=0; c<options.channels; c++) { 
    176179            b[c][q] = data[next++]; 
    177180          } 
     
    179182      } 
    180183      else { 
    181         for (int c=0; c<dims[0]; c++) { 
    182           System.arraycopy(data, c * x * y, b[c], 0, x * y); 
    183         } 
    184       } 
    185       DataBuffer buffer = new DataBufferByte(b, x * y); 
    186       img = AWTImageTools.constructImage(b.length, DataBuffer.TYPE_BYTE, x, y, 
    187         false, true, buffer); 
    188     } 
    189     else if (dims[1] == 2) { 
    190       short[][] s = new short[dims[0]][x * y]; 
    191       if (interleaved) { 
    192         for (int q=0; q<x*y; q++) { 
    193           for (int c=0; c<dims[0]; c++) { 
    194             s[c][q] = DataTools.bytesToShort(data, next, 2, littleEndian); 
     184        for (int c=0; c<options.channels; c++) { 
     185          System.arraycopy(data, c * plane, b[c], 0, plane); 
     186        } 
     187      } 
     188      DataBuffer buffer = new DataBufferByte(b, plane); 
     189      img = AWTImageTools.constructImage(b.length, DataBuffer.TYPE_BYTE, 
     190        options.width, options.height, false, true, buffer); 
     191    } 
     192    else if (options.bitsPerSample == 16) { 
     193      short[][] s = new short[options.channels][plane]; 
     194      if (options.interleaved) { 
     195        for (int q=0; q<plane; q++) { 
     196          for (int c=0; c<options.channels; c++) { 
     197            s[c][q] = 
     198              DataTools.bytesToShort(data, next, 2, options.littleEndian); 
    195199            next += 2; 
    196200          } 
     
    198202      } 
    199203      else { 
    200         for (int c=0; c<dims[0]; c++) { 
    201           for (int q=0; q<x*y; q++) { 
    202             s[c][q] = DataTools.bytesToShort(data, next, 2, littleEndian); 
     204        for (int c=0; c<options.channels; c++) { 
     205          for (int q=0; q<plane; q++) { 
     206            s[c][q] = 
     207              DataTools.bytesToShort(data, next, 2, options.littleEndian); 
    203208            next += 2; 
    204209          } 
    205210        } 
    206211      } 
    207       DataBuffer buffer = new DataBufferUShort(s, x * y); 
    208       img = AWTImageTools.constructImage(s.length, DataBuffer.TYPE_USHORT, x, y, 
    209         false, true, buffer); 
     212      DataBuffer buffer = new DataBufferUShort(s, plane); 
     213      img = AWTImageTools.constructImage(s.length, DataBuffer.TYPE_USHORT, 
     214        options.width, options.height, false, true, buffer); 
    210215    } 
    211216 
     
    228233  } 
    229234 
    230   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    231   public byte[] decompress(RandomAccessStream in, Object options) 
     235  /** 
     236   * The CodecOptions parameter should have the following fields set: 
     237   *  {@link CodecOptions#interleaved interleaved} 
     238   *  {@link CodecOptions#littleEndian littleEndian} 
     239   * 
     240   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     241   */ 
     242  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    232243    throws FormatException, IOException 
    233244  { 
    234     boolean littleEndian = false, interleaved = false; 
    235     long maxFP = 0; 
    236     if (options instanceof Boolean) { 
    237       littleEndian = ((Boolean) options).booleanValue(); 
    238     } 
    239     else { 
    240       Object[] o = (Object[]) options; 
    241       littleEndian = ((Boolean) o[0]).booleanValue(); 
    242       interleaved = ((Boolean) o[1]).booleanValue(); 
    243       if (o.length == 3) maxFP = ((Long) o[2]).longValue(); 
    244     } 
     245    if (options == null) options = CodecOptions.getDefaultOptions(); 
    245246 
    246247    byte[][] single = null, half = null; 
    247248    BufferedImage b = null; 
    248249    Exception exception = null; 
    249     long fp = in.getFilePointer(); 
     250    //long fp = in.getFilePointer(); 
    250251    try { 
    251       if (maxFP == 0) maxFP = in.length(); 
    252       byte[] buf = new byte[(int) (maxFP - fp)]; 
    253       in.read(buf); 
    254  
    255       ByteArrayInputStream bis = new ByteArrayInputStream(buf); 
    256       MemoryCacheImageInputStream mciis = new MemoryCacheImageInputStream(bis); 
     252      //if (maxFP == 0) maxFP = in.length(); 
     253      //byte[] buf = new byte[(int) (maxFP - fp)]; 
     254      //in.read(buf); 
     255 
     256      //ByteArrayInputStream bis = new ByteArrayInputStream(buf); 
     257      //MemoryCacheImageInputStream mciis = new MemoryCacheImageInputStream(bis); 
     258      MemoryCacheImageInputStream mciis = new MemoryCacheImageInputStream(in); 
    257259 
    258260      r.setVar("mciis", mciis); 
     
    260262      r.setVar("zero", 0); 
    261263      b = (BufferedImage) r.exec("j2kReader.read(zero)"); 
    262       single = AWTImageTools.getPixelBytes(b, littleEndian); 
    263  
    264       bis.close(); 
     264      single = AWTImageTools.getPixelBytes(b, options.littleEndian); 
     265 
     266      //bis.close(); 
    265267      mciis.close(); 
    266       buf = null; 
     268      //buf = null; 
    267269      b = null; 
    268270    } 
     
    281283    if (single.length == 1) return single[0]; 
    282284    byte[] rtn = new byte[single.length * single[0].length]; 
    283     if (interleaved) { 
     285    if (options.interleaved) { 
    284286      int next = 0; 
    285287      for (int i=0; i<single[0].length; i++) { 
  • trunk/components/bio-formats/src/loci/formats/codec/JPEGCodec.java

    r4645 r4681  
    4040 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/bio-formats/src/loci/formats/codec/JPEGCodec.java">SVN</a></dd></dl> 
    4141 */ 
    42 public class JPEGCodec extends BaseCodec implements Codec { 
     42public class JPEGCodec extends BaseCodec { 
    4343 
    44   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    45   public byte[] compress(byte[] data, int x, int y, 
    46       int[] dims, Object options) throws FormatException 
     44  /** 
     45   * The CodecOptions parameter should have the following fields set: 
     46   *  {@link CodecOptions#width width} 
     47   *  {@link CodecOptions#height height} 
     48   *  {@link CodecOptions#channels channels} 
     49   *  {@link CodecOptions#bitsPerSample bitsPerSample} 
     50   *  {@link CodecOptions#interleaved interleaved} 
     51   *  {@link CodecOptions#littleEndian littleEndian} 
     52   * 
     53   * @see Codec#compress(byte[], CodecOptions) 
     54   */ 
     55  public byte[] compress(byte[] data, CodecOptions options) 
     56    throws FormatException 
    4757  { 
    48     boolean littleEndian = false, interleaved = false; 
    49     if (options instanceof Boolean) { 
    50       littleEndian = ((Boolean) options).booleanValue(); 
    51     } 
    52     else { 
    53       Object[] o = (Object[]) options; 
    54       littleEndian = ((Boolean) o[0]).booleanValue(); 
    55       interleaved = ((Boolean) o[1]).booleanValue(); 
    56     } 
     58    if (options == null) options = CodecOptions.getDefaultOptions(); 
    5759 
    5860    ByteArrayOutputStream out = new ByteArrayOutputStream(); 
    59     BufferedImage img = AWTImageTools.makeImage(data, x, y, dims[0], 
    60       interleaved, dims[1], littleEndian); 
     61    BufferedImage img = AWTImageTools.makeImage(data, options.width, 
     62      options.height, options.channels, options.interleaved, 
     63      options.bitsPerSample / 8, options.littleEndian); 
    6164 
    6265    try { 
     
    6972  } 
    7073 
    71   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    72   public byte[] decompress(RandomAccessStream in, Object options) 
     74  /** 
     75   * The CodecOptions parameter should have the following fields set: 
     76   *  {@link CodecOptions#interleaved interleaved} 
     77   *  {@link CodecOptions#littleEndian littleEndian} 
     78   * 
     79   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     80   */ 
     81  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    7382    throws FormatException, IOException 
    7483  { 
     
    131140    } 
    132141 
    133     boolean littleEndian = true, interleaved = true; 
    134     if (options instanceof Boolean) { 
    135       littleEndian = ((Boolean) options).booleanValue(); 
    136     } 
    137     else { 
    138       Object[] o = (Object[]) options; 
    139       littleEndian = ((Boolean) o[0]).booleanValue(); 
    140       interleaved = ((Boolean) o[1]).booleanValue(); 
    141     } 
     142    if (options == null) options = CodecOptions.getDefaultOptions(); 
    142143 
    143     byte[][] buf = AWTImageTools.getPixelBytes(b, littleEndian); 
     144    byte[][] buf = AWTImageTools.getPixelBytes(b, options.littleEndian); 
    144145    byte[] rtn = new byte[buf.length * buf[0].length]; 
    145146    if (buf.length == 1) rtn = buf[0]; 
    146147    else { 
    147       if (interleaved) { 
     148      if (options.interleaved) { 
    148149        int next = 0; 
    149150        for (int i=0; i<buf[0].length; i++) { 
  • trunk/components/bio-formats/src/loci/formats/codec/LZOCodec.java

    r4521 r4681  
    3838 * @author Melissa Linkert linkert at wisc.edu 
    3939 */ 
    40 public class LZOCodec extends BaseCodec implements Codec { 
     40public class LZOCodec extends BaseCodec { 
    4141 
    4242  // LZO compression codes 
    4343  private static final int LZO_OVERRUN = -6; 
    4444 
    45   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    46   public byte[] compress(byte[] data, int x, int y, 
    47       int[] dims, Object options) throws FormatException 
     45  /* @see Codec#compress(byte[], CodecOptions) */ 
     46  public byte[] compress(byte[] data, CodecOptions options) 
     47    throws FormatException 
    4848  { 
    4949    // TODO: Add LZO compression support. 
     
    5151  } 
    5252 
    53   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    54   public byte[] decompress(RandomAccessStream in, Object options) 
     53  /* @see Codec#decompress(RandomAccessStream, CodecOptions) */ 
     54  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    5555    throws FormatException, IOException 
    5656  { 
  • trunk/components/bio-formats/src/loci/formats/codec/LZWCodec.java

    r4663 r4681  
    9494    {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f}; 
    9595 
    96   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    97   public byte[] compress(byte[] input, int x, int y, int[] dims, Object options) 
     96  /* @see Codec#compress(byte[], CodecOptions) */ 
     97  public byte[] compress(byte[] input, CodecOptions options) 
    9898    throws FormatException 
    9999  { 
     
    241241  } 
    242242 
    243   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    244   public byte[] decompress(RandomAccessStream in, Object options) 
     243  /** 
     244   * The CodecOptions parameter should have the following fields set: 
     245   *  {@link CodecOptions#maxBytes maxBytes} 
     246   * 
     247   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     248   */ 
     249  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    245250    throws FormatException, IOException 
    246251  { 
    247252    if (in == null || in.length() == 0) return null; 
    248     if (options == null) { 
    249       throw new FormatException("Options must be the maximum number of " + 
    250         "decompressed bytes."); 
    251     } 
    252  
    253     int outSize = ((Integer) options).intValue(); 
     253    if (options == null) options = CodecOptions.getDefaultOptions(); 
    254254 
    255255    // Output buffer 
    256     byte[] output = new byte[outSize]; 
     256    byte[] output = new byte[options.maxBytes]; 
    257257    // Position in output buffer to write next byte to 
    258258    int currOutPos = 0; 
  • trunk/components/bio-formats/src/loci/formats/codec/LuraWaveCodec.java

    r4623 r4681  
    4040 * @author Curtis Rueden ctrueden at wisc.edu 
    4141 */ 
    42 public class LuraWaveCodec extends BaseCodec implements Codec { 
     42public class LuraWaveCodec extends BaseCodec { 
    4343 
    4444  // -- Constants -- 
     
    9090  // -- Codec API methods -- 
    9191 
    92   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    93   public byte[] compress(byte[] data, int x, int y, 
    94     int[] dims, Object options) throws FormatException 
     92  /* @see Codec#compress(byte[], CodecOptions) */ 
     93  public byte[] compress(byte[] data, CodecOptions options) 
     94    throws FormatException 
    9595  { 
    9696    throw new FormatException("LuraWave compression not supported"); 
    9797  } 
    9898 
    99   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    100   public byte[] decompress(RandomAccessStream in, Object options) 
     99  /* @see Codec#decompress(RandomAccessStream, CodecOptions) */ 
     100  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    101101    throws FormatException, IOException 
    102102  { 
     
    106106  } 
    107107 
    108   /* @see Codec#decompress(byte[], Object) */ 
    109   public byte[] decompress(byte[] buf, Object options) throws FormatException { 
    110     int maxBytes = ((Integer) options).intValue(); 
    111  
     108  /** 
     109   * The CodecOptions parameter should have the following fields set: 
     110   *  {@link CodecOptions#maxBytes maxBytes} 
     111   * 
     112   * @see Codec#decompress(byte[], CodecOptions) 
     113   */ 
     114  public byte[] decompress(byte[] buf, CodecOptions options) 
     115    throws FormatException 
     116  { 
    112117    if (noLuraWave) throw new FormatException(NO_LURAWAVE_MSG); 
    113118    licenseCode = System.getProperty(LICENSE_PROPERTY); 
     
    133138    } 
    134139 
    135     int nbits = 8 * (maxBytes / (w * h)); 
     140    int nbits = 8 * (options.maxBytes / (w * h)); 
    136141 
    137142    if (nbits == 8) { 
  • trunk/components/bio-formats/src/loci/formats/codec/MJPBCodec.java

    r4521 r4681  
    3636 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/bio-formats/src/loci/formats/codec/MJPBCodec.java">SVN</a></dd></dl> 
    3737 */ 
    38 public class MJPBCodec extends BaseCodec implements Codec { 
     38public class MJPBCodec extends BaseCodec { 
    3939 
    4040  // -- Constants -- 
     
    4747  // -- Codec API methods -- 
    4848 
    49   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    50   public byte[] compress(byte[] data, int x, int y, int[] dims, Object options) 
     49  /* @see Codec#compress(byte[], CodecOptions) */ 
     50  public byte[] compress(byte[] data, CodecOptions options) 
    5151    throws FormatException 
    5252  { 
     
    5454  } 
    5555 
    56   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    57   public byte[] decompress(RandomAccessStream in, Object options) 
     56  /** 
     57   * The CodecOptions parameter must be an instance of {@link MJPBCodecOptions}, 
     58   * and should have the following fields set: 
     59   *  {@link MJPBCodecOptions#interlaced interlaced} 
     60   *  {@link CodecOptions#width width} 
     61   *  {@link CodecOptions#height height} 
     62   *  {@link CodecOptions#bitsPerSample bitsPerSample} 
     63   *  {@link CodecOptions#littleEndian littleEndian} 
     64   *  {@link CodecOptions#interleaved interleaved} 
     65   * 
     66   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     67   */ 
     68  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    5869    throws FormatException, IOException 
    5970  { 
    60     if (options == null || !(options instanceof int[])) return null; 
    61     int[] o = (int[]) options; 
    62     int x = o[0]; 
    63     int y = o[1]; 
    64     int bits = o[2]; 
    65     boolean interlaced = o[3] == 1; 
     71    if (options == null) options = CodecOptions.getDefaultOptions(); 
     72    if (!(options instanceof MJPBCodecOptions)) { 
     73      throw new FormatException("Options must be an instance of " + 
     74        "loci.formats.codec.MJPBCodecOptions"); 
     75    } 
    6676 
    6777    byte[] raw = null; 
     
    223233      v.add((byte) 0xc0); 
    224234 
    225       length = (bits >= 40) ? 11 : 17; 
     235      length = (options.bitsPerSample >= 40) ? 11 : 17; 
    226236      v.add((byte) ((length >>> 8) & 0xff)); 
    227237      v.add((byte) (length & 0xff)); 
    228238 
    229       int fieldHeight = y; 
    230       if (interlaced) fieldHeight /= 2; 
    231       if (y % 2 == 1) fieldHeight++; 
    232  
    233       int c = bits == 24 ? 3 : (bits == 32 ? 4 : 1); 
    234  
    235       v.add(bits >= 40 ? (byte) (bits - 32) : (byte) (bits / c)); 
     239      int fieldHeight = options.height; 
     240      if (((MJPBCodecOptions) options).interlaced) fieldHeight /= 2; 
     241      if (options.height % 2 == 1) fieldHeight++; 
     242 
     243      int c = options.bitsPerSample == 24 ? 3 : 
     244        (options.bitsPerSample == 32 ? 4 : 1); 
     245 
     246      v.add(options.bitsPerSample >= 40 ? (byte) (options.bitsPerSample - 32) : 
     247        (byte) (options.bitsPerSample / c)); 
    236248      v.add((byte) ((fieldHeight >>> 8) & 0xff)); 
    237249      v.add((byte) (fieldHeight & 0xff)); 
    238       v.add((byte) ((x >>> 8) & 0xff)); 
    239       v.add((byte) (x & 0xff)); 
    240       v.add((bits >= 40) ? (byte) 1 : (byte) 3); 
     250      v.add((byte) ((options.width >>> 8) & 0xff)); 
     251      v.add((byte) (options.width & 0xff)); 
     252      v.add((options.bitsPerSample >= 40) ? (byte) 1 : (byte) 3); 
    241253 
    242254      v.add((byte) 1); 
     
    244256      v.add((byte) 0); 
    245257 
    246       if (bits < 40) { 
     258      if (options.bitsPerSample < 40) { 
    247259        v.add((byte) 2); 
    248260        v.add((byte) 17); 
     
    256268      v.add((byte) 0xda); 
    257269 
    258       length = (bits >= 40) ? 8 : 12; 
     270      length = (options.bitsPerSample >= 40) ? 8 : 12; 
    259271      v.add((byte) ((length >>> 8) & 0xff)); 
    260272      v.add((byte) (length & 0xff)); 
    261273 
    262       v.add((bits >= 40) ? (byte) 1 : (byte) 3); 
     274      v.add((options.bitsPerSample >= 40) ? (byte) 1 : (byte) 3); 
    263275      v.add((byte) 1); 
    264276      v.add((byte) 0); 
    265277 
    266       if (bits < 40) { 
     278      if (options.bitsPerSample < 40) { 
    267279        v.add((byte) 2); 
    268280        v.add((byte) 1); 
     
    275287      v.add((byte) 0); 
    276288 
    277       if (interlaced) { 
     289      if (((MJPBCodecOptions) options).interlaced) { 
    278290        ByteVector v2 = new ByteVector(v.size()); 
    279291        v2.add(v.toByteArray()); 
     
    287299 
    288300        JPEGCodec jpeg = new JPEGCodec(); 
    289         byte[] top = jpeg.decompress(v.toByteArray(), Boolean.FALSE); 
    290         byte[] bottom = jpeg.decompress(v2.toByteArray(), Boolean.FALSE); 
    291  
    292         int bpp = bits < 40 ? bits / 8 : (bits - 32) / 8; 
    293         int ch = bits < 40 ? 3 : 1; 
    294         byte[] result = new byte[x * y * bpp * ch]; 
     301        byte[] top = jpeg.decompress(v.toByteArray(), options); 
     302        byte[] bottom = jpeg.decompress(v2.toByteArray(), options); 
     303 
     304        int bpp = options.bitsPerSample < 40 ? options.bitsPerSample / 8 : 
     305          (options.bitsPerSample - 32) / 8; 
     306        int ch = options.bitsPerSample < 40 ? 3 : 1; 
     307        byte[] result = new byte[options.width * options.height * bpp * ch]; 
    295308 
    296309        int topNdx = 0; 
    297310        int bottomNdx = 0; 
    298311 
    299         for (int yy=0; yy<y; yy++) { 
     312        int row = options.width * bpp; 
     313 
     314        for (int yy=0; yy<options.height; yy++) { 
    300315          if (yy % 2 == 0) { 
    301             System.arraycopy(top, topNdx*x*bpp, result, yy*x*bpp, x*bpp); 
     316            System.arraycopy(top, topNdx*row, result, yy*row, row); 
    302317            topNdx++; 
    303318          } 
    304319          else { 
    305             System.arraycopy(bottom, bottomNdx*x*bpp, result, yy*x*bpp, x*bpp); 
     320            System.arraycopy(bottom, bottomNdx*row, result, yy*row, row); 
    306321            bottomNdx++; 
    307322          } 
     
    313328        v.add((byte) 0xff); 
    314329        v.add((byte) 0xd9); 
    315         return new JPEGCodec().decompress(v.toByteArray(), Boolean.FALSE); 
     330        return new JPEGCodec().decompress(v.toByteArray(), options); 
    316331      } 
    317332    } 
  • trunk/components/bio-formats/src/loci/formats/codec/MSRLECodec.java

    r4521 r4681  
    3535 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/bio-formats/src/loci/formats/codec/MSRLECodec.java">SVN</a></dd></dl> 
    3636 */ 
    37 public class MSRLECodec extends BaseCodec implements Codec { 
     37public class MSRLECodec extends BaseCodec { 
    3838 
    39   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    40   public byte[] compress(byte[] data, int x, int y, int[] dims, Object options) 
     39  /* @see Codec#compress(byte[], CodecOptions) */ 
     40  public byte[] compress(byte[] data, CodecOptions options) 
    4141    throws FormatException 
    4242  { 
     
    4444  } 
    4545 
    46   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    47   public byte[] decompress(RandomAccessStream in, Object options) 
     46  /** 
     47   * The CodecOptions parameter should have the following fields set: 
     48   *  {@link CodecOptions#width width} 
     49   *  {@link CodecOptions#height height} 
     50   *  {@link CodecOptions#previousImage previousImage} 
     51   * 
     52   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     53   */ 
     54  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    4855    throws FormatException, IOException 
    4956  { 
    50     if (options == null || !(options instanceof Object[])) return null; 
    51  
    52     Object[] o = (Object[]) options; 
    53     byte[] prev = (byte[]) o[1]; 
    54     int[] dims = (int[]) o[0]; 
    55     int x = dims[0]; 
    56     int y = dims[1]; 
     57    if (options == null) options = CodecOptions.getDefaultOptions(); 
    5758 
    5859    int code = 0; 
     
    6162 
    6263    int pixelPt = 0; 
    63     int row = x; 
    64     int rowPt = (y - 1) * row; 
    65     int frameSize = y * row; 
     64    int rowPt = (options.height - 1) * options.width; 
     65    int frameSize = options.height * options.width; 
    6666 
    67     if (prev == null) prev = new byte[frameSize]; 
     67    if (options.previousImage == null) { 
     68      options.previousImage = new byte[frameSize]; 
     69    } 
    6870 
    6971    while (rowPt >= 0 && in.getFilePointer() < in.length() && 
    70       pixelPt < prev.length) 
     72      pixelPt < options.previousImage.length) 
    7173    { 
    7274      stream = in.read() & 0xff; 
     
    7678        stream = in.read() & 0xff; 
    7779        if (stream == 0) { 
    78           rowPt -= row; 
     80          rowPt -= options.width; 
    7981          pixelPt = 0; 
    8082        } 
    81         else if (stream == 1) return prev; 
     83        else if (stream == 1) return options.previousImage; 
    8284        else if (stream == 2) { 
    8385          stream = in.read() & 0xff; 
    8486          pixelPt += stream; 
    8587          stream = in.read() & 0xff; 
    86           rowPt -= stream * row; 
     88          rowPt -= stream * options.width; 
    8789        } 
    8890        else { 
    8991          if ((rowPt + pixelPt + stream > frameSize) || (rowPt < 0)) { 
    90             return prev; 
     92            return options.previousImage; 
    9193          } 
    9294 
    9395          code = stream; 
    9496          extra = (short) (stream & 0x01); 
    95           if (stream + code + extra > in.length()) return prev; 
     97          if (stream + code + extra > in.length()) return options.previousImage; 
    9698 
    9799          while (code-- > 0) { 
    98100            stream = in.read(); 
    99             prev[rowPt + pixelPt] = (byte) stream; 
     101            options.previousImage[rowPt + pixelPt] = (byte) stream; 
    100102            pixelPt++; 
    101103          } 
     
    105107      else { 
    106108        if ((rowPt + pixelPt + stream > frameSize) || (rowPt < 0)) { 
    107           return prev; 
     109          return options.previousImage; 
    108110        } 
    109111 
     
    111113 
    112114        while (code-- > 0) { 
    113           prev[rowPt + pixelPt] = (byte) stream; 
     115          options.previousImage[rowPt + pixelPt] = (byte) stream; 
    114116          pixelPt++; 
    115117        } 
     
    117119    } 
    118120 
    119     return prev; 
     121    return options.previousImage; 
    120122  } 
    121123 
  • trunk/components/bio-formats/src/loci/formats/codec/MSVideoCodec.java

    r4521 r4681  
    3838 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/bio-formats/src/loci/formats/codec/MSVideoCodec.java">SVN</a></dd></dl> 
    3939 */ 
    40 public class MSVideoCodec extends BaseCodec implements Codec { 
    41  
    42   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    43   public byte[] compress(byte[] data, int x, int y, int[] dims, Object options) 
     40public class MSVideoCodec extends BaseCodec { 
     41 
     42  /* @see Codec#compress(byte[], CodecOptions) */ 
     43  public byte[] compress(byte[] data, CodecOptions options) 
    4444    throws FormatException 
    4545  { 
     
    4747  } 
    4848 
    49   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    50   public byte[] decompress(RandomAccessStream in, Object options) 
     49  /** 
     50   * The CodecOptions parameter should have the following fields set: 
     51   *  {@link CodecOptions#width width} 
     52   *  {@link CodecOptions#height height} 
     53   *  {@link CodecOptions#bitsPerSample bitsPerSample} 
     54   *  {@link CodecOptions#previousImage previousImage} 
     55   * 
     56   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     57   */ 
     58  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    5159    throws FormatException, IOException 
    5260  { 
    53     if (options == null || !(options instanceof Object[])) return null; 
    54     Object[] optionsArray = (Object[]) options; 
    55     int bitsPerPixel = ((Integer) optionsArray[0]).intValue(); 
    56     int width = ((Integer) optionsArray[1]).intValue(); 
    57     int height = ((Integer) optionsArray[2]).intValue(); 
    58     byte[] lastImage = (byte[]) optionsArray[3]; 
     61    if (options == null) options = CodecOptions.getDefaultOptions(); 
    5962 
    6063    in.order(true); 
     
    6366    int column = 0; 
    6467 
    65     byte[] bytes = new byte[width * height]; 
    66     short[] shorts = new short[width * height]; 
     68    int plane = options.width * options.height; 
     69 
     70    byte[] bytes = new byte[plane]; 
     71    short[] shorts = new short[plane]; 
    6772 
    6873    while (true) { 
    69       if (in.getFilePointer() >= in.length() || row >= width || 
    70         column >= height) 
     74      if (in.getFilePointer() >= in.length() || row >= options.width || 
     75        column >= options.height) 
    7176      { 
    7277        break; 
     
    8085        int skip = (b - 0x84) * 256 + a; 
    8186        for (int i=0; i<skip; i++) { 
    82           if (lastImage != null) { 
     87          if (options.previousImage != null) { 
    8388            for (int y=0; y<4; y++) { 
    8489              for (int x=0; x<4; x++) { 
    85                 if (row + x >= width) break; 
    86                 if (column + y >= height) break; 
    87                 int ndx = width*(column + y) + row + x; 
    88                 int oldNdx = width*(height - 1 - y - column) + row + x; 
    89                 if (bitsPerPixel == 8) { 
    90                   bytes[ndx] = lastImage[oldNdx]; 
     90                if (row + x >= options.width) break; 
     91                if (column + y >= options.height) break; 
     92                int ndx = options.width*(column + y) + row + x; 
     93                int oldNdx = 
     94                  options.width*(options.height - 1 - y - column) + row + x; 
     95                if (options.bitsPerSample == 8) { 
     96                  bytes[ndx] = options.previousImage[oldNdx]; 
    9197                } 
    9298                else { 
    93                   byte red = lastImage[oldNdx]; 
    94                   byte green = lastImage[oldNdx + width*height]; 
    95                   byte blue = lastImage[oldNdx + 2*width*height]; 
     99                  byte red = options.previousImage[oldNdx]; 
     100                  byte green = options.previousImage[oldNdx + plane]; 
     101                  byte blue = options.previousImage[oldNdx + 2*plane]; 
    96102                  shorts[ndx] = (short) (((blue & 0x1f) << 10) | 
    97103                    ((green & 0x1f) << 5) | (red & 0x1f)); 
     
    102108 
    103109          row += 4; 
    104           if (row >= width) { 
     110          if (row >= options.width) { 
    105111            row = 0; 
    106112            column += 4; 
     
    109115      } 
    110116      else if (b >= 0 && b < 0x80) { 
    111         if (bitsPerPixel == 8) { 
     117        if (options.bitsPerSample == 8) { 
    112118          byte colorA = in.readByte(); 
    113119          byte colorB = in.readByte(); 
     
    115121          for (int y=0; y<4; y++) { 
    116122            for (int x=3; x>=0; x--) { 
    117               int ndx = width*(column + y) + row + x; 
     123              int ndx = options.width*(column + y) + row + x; 
    118124              short flag = y < 2 ? b : a; 
    119125              int shift = 4 - 4*(y % 2) + x; 
     
    141147            for (int y=0; y<4; y++) { 
    142148              for (int x=3; x>= 0; x--) { 
    143                 int ndx = width*(column + y) + row + x; 
     149                int ndx = options.width*(column + y) + row + x; 
    144150 
    145151                short colorA = 
     
    164170            for (int y=0; y<4; y++) { 
    165171              for (int x=3; x>=0; x--) { 
    166                 int ndx = width*(column + y) + row + x; 
     172                int ndx = options.width*(column + y) + row + x; 
    167173                if (ndx >= shorts.length) break; 
    168174                short flag = y < 2 ? b : a; 
     
    177183 
    178184        row += 4; 
    179         if (row >= width) { 
     185        if (row >= options.width) { 
    180186          row = 0; 
    181187          column += 4; 
    182188        } 
    183189      } 
    184       else if (bitsPerPixel == 8 && 0x90 < b) { 
     190      else if (options.bitsPerSample == 8 && 0x90 < b) { 
    185191        byte[] colors = new byte[8]; 
    186192        in.read(colors); 
     
    188194        for (int y=0; y<4; y++) { 
    189195          for (int x=3; x>=0; x--) { 
    190             int ndx = width*(column + y) + row + x; 
     196            int ndx = options.width*(column + y) + row + x; 
    191197            byte colorA = y < 2 ? (x < 2 ? colors[4] : colors[6]) : 
    192198              (x < 2 ? colors[0] : colors[2]); 
     
    205211        for (int y=0; y<4; y++) { 
    206212          for (int x=0; x<4; x++) { 
    207             int ndx = width*(column + y) + row + x; 
    208             if (bitsPerPixel == 8) bytes[ndx] = (byte) (a & 0xff); 
     213            int ndx = options.width*(column + y) + row + x; 
     214            if (options.bitsPerSample == 8) bytes[ndx] = (byte) (a & 0xff); 
    209215            else shorts[ndx] = (short) (((b << 8) | a) & 0xffff); 
    210216          } 
    211217        } 
    212218        row += 4; 
    213         if (row >= width) { 
     219        if (row >= options.width) { 
    214220          row = 0; 
    215221          column += 4; 
     
    218224    } 
    219225 
    220     if (bitsPerPixel == 8) { 
     226    if (options.bitsPerSample == 8) { 
    221227      byte[] tmp = bytes; 
    222228      bytes = new byte[tmp.length]; 
    223       for (int y=0; y<height; y++) { 
    224         System.arraycopy(tmp, y*width, bytes, (height-y-1)*width, width); 
     229      for (int y=0; y<options.height; y++) { 
     230        System.arraycopy(tmp, y*options.width, bytes, 
     231          (options.height-y-1)*options.width, options.width); 
    225232      } 
    226233      return bytes; 
    227234    } 
    228235 
    229     byte[] b = new byte[width * height * 3]; 
     236    byte[] b = new byte[plane * 3]; 
    230237    // expand RGB 5-5-5 to 3 byte tuple 
    231238 
    232     for (int y=0; y<height; y++) { 
    233       for (int x=0; x<width; x++) { 
    234         int off = y*width + x; 
    235         int dest = (height - y - 1)*width + x; 
    236         b[dest + 2*width*height] = (byte) ((shorts[off] & 0x7c00) >> 10); 
    237         b[dest + width*height] = (byte) ((shorts[off] & 0x3e0) >> 5); 
     239    for (int y=0; y<options.height; y++) { 
     240      for (int x=0; x<options.width; x++) { 
     241        int off = y*options.width + x; 
     242        int dest = (options.height - y - 1)*options.width + x; 
     243        b[dest + 2*plane] = (byte) ((shorts[off] & 0x7c00) >> 10); 
     244        b[dest + plane] = (byte) ((shorts[off] & 0x3e0) >> 5); 
    238245        b[dest] = (byte) (shorts[off] & 0x1f); 
    239246      } 
  • trunk/components/bio-formats/src/loci/formats/codec/NikonCodec.java

    r4555 r4681  
    4343 * @author Melissa Linkert linkert at wisc.edu 
    4444 */ 
    45 public class NikonCodec extends BaseCodec implements Codec { 
     45public class NikonCodec extends BaseCodec { 
    4646 
    4747  private static final int[] DEFAULT_LINEARIZATION_TABLE = { 
     
    132132  private Decoder decoder; 
    133133 
    134   private int[] vPredictor = new int[4]; 
    135134  private static int leafCounter; 
    136135 
    137   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    138   public byte[] compress(byte[] data, int x, int y, 
    139     int[] dims, Object options) throws FormatException 
     136  /* @see Codec#compress(byte[], CodecOptions) */ 
     137  public byte[] compress(byte[] data, CodecOptions options) 
     138    throws FormatException 
    140139  { 
    141140    // TODO: Add compression support. 
     
    143142  } 
    144143 
    145   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    146   public byte[] decompress(RandomAccessStream in, Object options) 
     144  /** 
     145   * The CodecOptions parameter must be an instance of 
     146   * {@link NikonCodecOptions}, and should have the following fields set: 
     147   *  {@link NikonCodecOptions#lossy lossy} 
     148   *  {@link NikonCodecOptions#vPredictor vPredictor} 
     149   *  {@link NikonCodecOptions#curve curve} 
     150   *  {@link NikonCodecOptions#split split} 
     151   *  {@link CodecOptions#bitsPerSample bitsPerSample} 
     152   *  {@link CodecOptions#maxBytes maxBytes} 
     153   *  {@link CodecOptions#width width} 
     154   *  {@link CodecOptions#height height} 
     155   * 
     156   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     157   */ 
     158  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    147159    throws FormatException, IOException 
    148160  { 
    149     Object[] o = (Object[]) options; 
    150     int[] curve = (int[]) o[0]; 
    151     int bps = ((Integer) o[1]).intValue(); 
    152     int availableBytes = ((Integer) o[2]).intValue(); 
    153     int width = ((Integer) o[3]).intValue(); 
    154     int height = ((Integer) o[4]).intValue(); 
    155     vPredictor = (int[]) o[5]; 
    156     boolean lossy = ((Boolean) o[6]).booleanValue(); 
    157     int split = ((Integer) o[7]).intValue(); 
    158  
    159     if (lossy) { 
    160       if (bps == 12) decoder = new Decoder(LOSSY_DECODER_CONFIGURATION_12); 
     161    if (options == null) options = CodecOptions.getDefaultOptions(); 
     162    if (!(options instanceof NikonCodecOptions)) { 
     163      throw new FormatException("Options must be an instanceof " + 
     164        "loci.formats.codec.NikonCodecOptions."); 
     165    } 
     166 
     167    NikonCodecOptions nikon = (NikonCodecOptions) options; 
     168 
     169    if (nikon.lossy) { 
     170      if (nikon.bitsPerSample == 12) { 
     171        decoder = new Decoder(LOSSY_DECODER_CONFIGURATION_12); 
     172      } 
    161173      else decoder = new Decoder(LOSSY_DECODER_CONFIGURATION_14); 
    162174    } 
    163175    else { 
    164       if (bps == 12) decoder = new Decoder(LOSSLESS_DECODER_CONFIGURATION_12); 
     176      if (nikon.bitsPerSample == 12) { 
     177        decoder = new Decoder(LOSSLESS_DECODER_CONFIGURATION_12); 
     178      } 
    165179      else decoder = new Decoder(LOSSLESS_DECODER_CONFIGURATION_14); 
    166180    } 
    167181 
    168     if (vPredictor == null) { 
    169       vPredictor = new int[] {0, 0, 0, 0}; 
    170     } 
    171  
    172     byte[] pix = new byte[availableBytes]; 
     182    if (nikon.vPredictor == null) { 
     183      nikon.vPredictor = new int[] {0, 0, 0, 0}; 
     184    } 
     185 
     186    byte[] pix = new byte[nikon.maxBytes]; 
    173187    in.read(pix); 
    174188 
     
    177191 
    178192    int[] hPredictor = new int[2]; 
    179     int[] table = curve == null ? DEFAULT_LINEARIZATION_TABLE : curve; 
    180  
    181     for (int row=0; row<height; row++) { 
    182       if (row == split) { 
    183         if (lossy) { 
    184           if (bps == 12) { 
     193    int[] table = nikon.curve == null ? DEFAULT_LINEARIZATION_TABLE : 
     194      nikon.curve; 
     195 
     196    for (int row=0; row<nikon.height; row++) { 
     197      if (row == nikon.split) { 
     198        if (nikon.lossy) { 
     199          if (nikon.bitsPerSample == 12) { 
    185200            decoder = new Decoder(SPLIT_LOSSY_DECODER_CONFIGURATION_12); 
    186201          } 
     
    189204        } 
    190205      } 
    191       for (int col=0; col<width; col++) { 
     206      for (int col=0; col<nikon.width; col++) { 
    192207        int cfaIndex = (2 * (row & 1)) + (col & 1); 
    193208        int bitsCount = decoder.decode(bb); 
     
    198213 
    199214        if (col < 2) { 
    200           vPredictor[cfaIndex] += diff; 
    201           hPredictor[col & 1] = vPredictor[cfaIndex]; 
     215          nikon.vPredictor[cfaIndex] += diff; 
     216          hPredictor[col & 1] = nikon.vPredictor[cfaIndex]; 
    202217        } 
    203218        else { 
     
    209224          index = table.length - 1; 
    210225        } 
    211         out.write(table[index], bps); 
     226        out.write(table[index], options.bitsPerSample); 
    212227      } 
    213228    } 
  • trunk/components/bio-formats/src/loci/formats/codec/PackbitsCodec.java

    r4521 r4681  
    3838 * @author Melissa Linkert linkert at wisc.edu 
    3939 */ 
    40 public class PackbitsCodec extends BaseCodec implements Codec { 
     40public class PackbitsCodec extends BaseCodec { 
    4141 
    42   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    43   public byte[] compress(byte[] data, int x, int y, 
    44       int[] dims, Object options) throws FormatException 
     42  /* @see Codec#compress(byte[], CodecOptions) */ 
     43  public byte[] compress(byte[] data, CodecOptions options) 
     44    throws FormatException 
    4545  { 
    4646    // TODO: Add compression support. 
     
    4848  } 
    4949 
    50   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    51   public byte[] decompress(RandomAccessStream in, Object options) 
     50  /** 
     51   * The CodecOptions parameter should have the following fields set: 
     52   *  {@link CodecOptions#maxBytes maxBytes} 
     53   * 
     54   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     55   */ 
     56  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    5257    throws FormatException, IOException 
    5358  { 
    5459    // Adapted from the TIFF 6.0 specification, page 42. 
    55     int expected = ((Integer) options).intValue(); 
    5660    ByteVector output = new ByteVector(1024); 
    57     while (output.size() < expected && in.getFilePointer() < in.length()) { 
     61    while (output.size() < options.maxBytes && 
     62      in.getFilePointer() < in.length()) 
     63    { 
    5864      byte n = in.readByte(); 
    5965      if (n >= 0) { // 0 <= n <= 127 
  • trunk/components/bio-formats/src/loci/formats/codec/QTRLECodec.java

    r4666 r4681  
    3535 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/bio-formats/src/loci/formats/codec/QTRLECodec.java">SVN</a></dd></dl> 
    3636 */ 
    37 public class QTRLECodec extends BaseCodec implements Codec { 
     37public class QTRLECodec extends BaseCodec { 
    3838 
    39   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    40   public byte[] compress(byte[] data, int x, int y, int[] dims, Object options) 
     39  /* @see Codec#compress(byte[], CodecOptions) */ 
     40  public byte[] compress(byte[] data, CodecOptions options) 
    4141    throws FormatException 
    4242  { 
     
    4444  } 
    4545 
    46   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    47   public byte[] decompress(RandomAccessStream in, Object options) 
     46  /* @see Codec#decompress(RandomAccessStream, CodecOptions) */ 
     47  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    4848    throws FormatException, IOException 
    4949  { 
     
    5353  } 
    5454 
    55   /* @see Codec#decompress(byte[], Object) */ 
    56   public byte[] decompress(byte[] data, Object options) throws FormatException { 
    57     if (options == null || !(options instanceof Object[])) return null; 
     55  /** 
     56   * The CodecOptions parameter should have the following fields set: 
     57   *  {@link CodecOptions#width width} 
     58   *  {@link CodecOptions#height height} 
     59   *  {@link CodecOptions#bitsPerSample bitsPerSample} 
     60   *  {@link CodecOptions#previousImage previousImage} 
     61   * 
     62   * @see Codec#decompress(byte[], CodecOptions) 
     63   */ 
     64  public byte[] decompress(byte[] data, CodecOptions options) 
     65    throws FormatException 
     66  { 
     67    if (options == null) options = CodecOptions.getDefaultOptions(); 
    5868 
    59     Object[] o = (Object[]) options; 
    60     byte[] prev = (byte[]) o[1]; 
    61     int[] dims = (int[]) o[0]; 
    62     int x = dims[0]; 
    63     int y = dims[1]; 
    64     int bpp = dims[2]; 
    65     int numLines = y; 
     69    int numLines = options.height; 
    6670 
    67     if (data.length < 8) return prev; 
     71    if (data.length < 8) return options.previousImage; 
    6872 
    69     int line = x * bpp; 
     73    int bpp = options.bitsPerSample / 8; 
     74    int line = options.width * bpp; 
    7075 
    7176    try { 
     
    7782      int start = 0; 
    7883 
    79       byte[] output = new byte[y * line]; 
     84      byte[] output = new byte[options.height * line]; 
    8085 
    8186      if ((header & 8) == 8) { 
     
    8590        s.skipBytes(2); 
    8691 
    87         if (prev != null) { 
     92        if (options.previousImage != null) { 
    8893          for (int i=0; i<start; i++) { 
    89             System.arraycopy(prev, off, output, off, line); 
     94            System.arraycopy(options.previousImage, off, output, off, line); 
    9095            off += line; 
    9196          } 
    9297        } 
    9398 
    94         if (prev != null) { 
     99        if (options.previousImage != null) { 
    95100          off = line * (start + numLines); 
    96           for (int i=start+numLines; i<y; i++) { 
    97             System.arraycopy(prev, off, output, off, line); 
     101          for (int i=start+numLines; i<options.height; i++) { 
     102            System.arraycopy(options.previousImage, off, output, off, line); 
    98103            off += line; 
    99104          } 
     
    113118        if (skip < 0) skip += 256; 
    114119 
    115         if (prev != null) { 
     120        if (options.previousImage != null) { 
    116121          try { 
    117             System.arraycopy(prev, rowPointer, output, rowPointer, 
    118               (skip - 1) * bpp); 
     122            System.arraycopy(options.previousImage, rowPointer, output, 
     123              rowPointer, (skip - 1) * bpp); 
    119124          } 
    120125          catch (ArrayIndexOutOfBoundsException e) { } 
     
    128133            skip = s.read(); 
    129134 
    130             if (prev != null) { 
     135            if (options.previousImage != null) { 
    131136              try { 
    132                 System.arraycopy(prev, off, output, off, (skip - 1) * bpp); 
     137                System.arraycopy(options.previousImage, off, output, off, 
     138                  (skip - 1) * bpp); 
    133139              } 
    134140              catch (ArrayIndexOutOfBoundsException e) { } 
     
    138144          } 
    139145          else if (rle == -1) { 
    140             if (off < (rowPointer + line) && prev != null) { 
    141               System.arraycopy(prev, off, output, off, rowPointer + line - off); 
     146            if (off < (rowPointer + line) && options.previousImage != null) { 
     147              System.arraycopy(options.previousImage, off, output, off, 
     148                rowPointer + line - off); 
    142149            } 
    143150            break; 
  • trunk/components/bio-formats/src/loci/formats/codec/RPZACodec.java

    r4666 r4681  
    3636 * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/components/bio-formats/src/loci/formats/codec/RPZACodec.java">SVN</a></dd></dl> 
    3737 */ 
    38 public class RPZACodec extends BaseCodec implements Codec { 
    39  
    40   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    41   public byte[] compress(byte[] input, int x, int y, int[] dims, 
    42     Object options) throws FormatException 
     38public class RPZACodec extends BaseCodec { 
     39 
     40  // -- Fields -- 
     41 
     42  private int totalBlocks, pixelPtr, rowPtr, stride; 
     43 
     44  /* @see Codec#compress(byte[], CodecOptions) */ 
     45  public byte[] compress(byte[] input, CodecOptions options) 
     46    throws FormatException 
    4347  { 
    4448    throw new FormatException("RPZA compression not supported."); 
    4549  } 
    4650 
    47   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    48   public byte[] decompress(RandomAccessStream in, Object options) 
     51  /** 
     52   * The CodecOptions parameter should have the following fields set: 
     53   *  {@link CodecOptions#width width} 
     54   *  {@link CodecOptions#height height} 
     55   * 
     56   * @see Codec#decompress(RandomAccessStream, CodecOptions) 
     57   */ 
     58  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    4959    throws FormatException, IOException 
    5060  { 
    51     if (options == null || !(options instanceof int[])) return null; 
    52  
    53     int[] o = (int[]) options; 
    54     int x = o[0]; 
    55     int y = o[1]; 
     61    if (options == null) options = CodecOptions.getDefaultOptions(); 
    5662 
    5763    in.skipBytes(8); 
    5864 
    59     int stride = x; 
     65    int plane = options.width * options.height; 
     66 
     67    stride = options.width; 
    6068    int rowInc = stride - 4; 
    6169    short opcode; 
     
    6573    int index, idx; 
    6674    int ta, tb; 
    67     int rowPtr = 0, pixelPtr = 0, blockPtr = 0; 
     75    int blockPtr = 0; 
     76    rowPtr = pixelPtr = 0; 
    6877    int pixelX, pixelY; 
    69     int totalBlocks; 
    70  
    71     int[] pixels = new int[x * y]; 
    72     byte[] rtn = new byte[x * y * 3]; 
     78 
     79    int[] pixels = new int[plane]; 
     80    byte[] rtn = new byte[plane * 3]; 
    7381 
    7482    while (in.read() != (byte) 0xe1); 
    7583    in.skipBytes(3); 
    7684 
    77     totalBlocks = ((x + 3) / 4) * ((y + 3) / 4); 
     85    totalBlocks = ((options.width + 3) / 4) * ((options.height + 3) / 4); 
    7886 
    7987    while (in.getFilePointer() + 2 < in.length()) { 
     
    96104        case 0x80: 
    97105          while (nBlocks-- > 0) { 
    98             pixelPtr += 4; 
    99             if (pixelPtr >= x) { 
    100               pixelPtr = 0; 
    101               rowPtr += stride * 4; 
    102             } 
    103             totalBlocks--; 
     106            updateBlock(options.width); 
    104107          } 
    105108          break; 
     
    120123              blockPtr += rowInc; 
    121124            } 
    122             pixelPtr += 4; 
    123             if (pixelPtr >= x) { 
    124               pixelPtr = 0; 
    125               rowPtr += stride * 4; 
    126             } 
    127             totalBlocks--; 
     125            updateBlock(options.width); 
    128126          } 
    129127          break; 
     
    173171              blockPtr += rowInc; 
    174172            } 
    175             pixelPtr += 4; 
    176             if (pixelPtr >= x) { 
    177               pixelPtr = 0; 
    178               rowPtr += stride * 4; 
    179             } 
    180             totalBlocks--; 
     173            updateBlock(options.width); 
    181174          } 
    182175          break; 
     
    198191            blockPtr += rowInc; 
    199192          } 
    200           pixelPtr += 4; 
    201           if (pixelPtr >= x) { 
    202             pixelPtr = 0; 
    203             rowPtr += stride * 4; 
    204           } 
    205           totalBlocks--; 
     193          updateBlock(options.width); 
    206194          break; 
    207195      } 
     
    217205    array[offset + 2*len] = (byte) (255 - (s & 0x1f)); 
    218206  } 
     207 
     208  private void updateBlock(int width) { 
     209    pixelPtr += 4; 
     210    if (pixelPtr >= width) { 
     211      pixelPtr = 0; 
     212      rowPtr += stride * 4; 
     213    } 
     214    totalBlocks--; 
     215  } 
     216 
    219217} 
  • trunk/components/bio-formats/src/loci/formats/codec/ZlibCodec.java

    r4670 r4681  
    3939 * @author Melissa Linkert linkert at wisc.edu 
    4040 */ 
    41 public class ZlibCodec extends BaseCodec implements Codec { 
     41public class ZlibCodec extends BaseCodec { 
    4242 
    43   /* @see Codec#compress(byte[], int, int, int[], Object) */ 
    44   public byte[] compress(byte[] data, int x, int y, 
    45     int[] dims, Object options) throws FormatException 
     43  /* @see Codec#compress(byte[], CodecOptions) */ 
     44  public byte[] compress(byte[] data, CodecOptions options) 
     45    throws FormatException 
    4646  { 
    4747    Deflater deflater = new Deflater(); 
     
    5858  } 
    5959 
    60   /* @see Codec#decompress(RandomAccessStream, Object) */ 
    61   public byte[] decompress(RandomAccessStream in, Object options) 
     60  /* @see Codec#decompress(RandomAccessStream, CodecOptions) */ 
     61  public byte[] decompress(RandomAccessStream in, CodecOptions options) 
    6262    throws FormatException, IOException 
    6363  { 
  • trunk/components/bio-formats/src/loci/formats/in/AVIReader.java

    r4648 r4681  
    543543    throws FormatException, IOException 
    544544  { 
     545    CodecOptions options = new CodecOptions(); 
     546    options.width = getSizeX(); 
     547    options.height = getSizeY(); 
     548    options.previousImage = (lastImageNo == no - 1) ? lastImage : null; 
     549    options.bitsPerSample = bmpBitsPerPixel; 
     550 
    545551    if (bmpCompression == MSRLE) { 
    546552      byte[] b = new byte[(int) ((Long) lengths.get(no)).longValue()]; 
    547553      in.read(b); 
    548       Object[] options = new Object[2]; 
    549       options[1] = (lastImageNo == no - 1) ? lastImage : null; 
    550       options[0] = new int[] {getSizeX(), getSizeY()}; 
    551554      MSRLECodec codec = new MSRLECodec(); 
    552555      buf = codec.decompress(b, options); 
     
    555558    } 
    556559    else if (bmpCompression == MS_VIDEO) { 
    557       Object[] options = new Object[4]; 
    558       options[0] = new Integer(bmpBitsPerPixel); 
    559       options[1] = new Integer(getSizeX()); 
    560       options[2] = new Integer(getSizeY()); 
    561       options[3] = (lastImageNo == no - 1) ? lastImage : null; 
    562  
    563560      MSVideoCodec codec = new MSVideoCodec(); 
    564561      buf = codec.decompress(in, options); 
  • trunk/components/bio-formats/src/loci/formats/in/DicomReader.java

    r4648 r4681  
    179179    if (isRLE) { 
    180180      // plane is compressed using run-length encoding 
     181      CodecOptions options = new CodecOptions(); 
     182      options.maxBytes = bytes / ec; 
    181183      for (int c=0; c<ec; c++) { 
    182184        PackbitsCodec codec = new PackbitsCodec(); 
    183         byte[] t = codec.decompress(in, new Integer(bytes / ec)); 
     185        byte[] t = codec.decompress(in, options); 
    184186        if (t.length < (bytes / ec)) { 
    185187          byte[] tmp = t; 
     
    231233      } 
    232234      Codec codec = null; 
     235      CodecOptions options = new CodecOptions(); 
     236      options.littleEndian = isLittleEndian(); 
     237      options.interleaved = isInterleaved(); 
    233238      if (isJPEG) codec = new JPEGCodec(); 
    234239      else codec = new JPEG2000Codec(); 
    235       b = codec.decompress(b, new Object[] {new Boolean(isLittleEndian()), 
    236         new Boolean(isInterleaved())}); 
     240      b = codec.decompress(b, options); 
    237241 
    238242      int rowLen = w * bpp; 
     
    494498        else { 
    495499          in.seek(offsets[i - 1]); 
    496           new PackbitsCodec().decompress(in, new Integer(plane)); 
     500          CodecOptions options = new CodecOptions(); 
     501          options.maxBytes = plane; 
     502          new PackbitsCodec().decompress(in, options); 
    497503        } 
    498504        in.skipBytes(i == 0 ? 64 : 53); 
  • trunk/components/bio-formats/src/loci/formats/in/ND2Reader.java

    r4670 r4681  
    126126      in.length() : offsets[series][no + 1]; 
    127127 
     128    CodecOptions options = new CodecOptions(); 
     129    options.littleEndian = isLittleEndian(); 
     130    options.interleaved = isInterleaved(); 
     131    options.maxBytes = (int) maxFP; 
     132 
    128133    if (isJPEG) { 
    129       byte[] tmp = new JPEG2000Codec().decompress(in, new Object[] { 
    130         new Boolean(isLittleEndian()), 
    131         new Boolean(isInterleaved()), new Long(maxFP)}); 
     134      byte[] tmp = new JPEG2000Codec().decompress(in, options); 
    132135      for (int row=y; row<h+y; row++) { 
    133136        System.arraycopy(tmp, pixel * row * getSizeX(), buf, 
     
    142145      int effectiveX = getSizeX(); 
    143146      if ((getSizeX() % 2) != 0) effectiveX++; 
    144       byte[] t = new ZlibCodec().decompress(in, null); 
     147      byte[] t = new ZlibCodec().decompress(in, options); 
    145148 
    146149      for (int row=0; row<h; row++) { 
  • trunk/components/bio-formats/src/loci/formats/in/NikonReader.java

    r4555 r4681  
    2828import loci.common.*; 
    2929import loci.formats.*; 
    30 import loci.formats.codec.BitBuffer; 
    31 import loci.formats.codec.ByteVector; 
    32 import loci.formats.codec.NikonCodec; 
     30import loci.formats.codec.*; 
    3331 
    3432/** 
     
    178176    long[] rowsPerStrip = TiffTools.getRowsPerStrip(ifds[no]); 
    179177 
    180     ByteVector src = new ByteVector(); 
    181  
    182178    float bytesPerSample = (float) dataSize / 8; 
    183179    boolean maybeCompressed = 
     
    187183    if (!maybeCompressed && dataSize == 14) dataSize = 16; 
    188184 
     185    ByteArrayOutputStream src = new ByteArrayOutputStream(); 
     186 
    189187    for (int i=0; i<byteCounts.length; i++) { 
    190188      byte[] t = new byte[(int) byteCounts[i]]; 
     
    193191      in.read(t); 
    194192      if (compressed) { 
    195         Object[] options = new Object[8]; 
    196         options[0] = curve; 
    197         options[1] = new Integer(dataSize); 
    198         options[2] = new Integer((int) byteCounts[i]); 
    199         options[3] = new Integer(getSizeX()); 
    200         options[4] = new Integer(getSizeY()); 
    201         options[5] = vPredictor; 
    202         options[6] = new Boolean(lossyCompression); 
    203         options[7] = new Integer(split); 
     193        NikonCodecOptions options = new NikonCodecOptions(); 
     194        options.width = getSizeX(); 
     195        options.height = getSizeY(); 
     196        options.bitsPerSample = dataSize; 
     197        options.curve = curve; 
     198        options.vPredictor = vPredictor; 
     199        options.lossy = lossyCompression; 
     200        options.split = split; 
     201        options.maxBytes = (int) byteCounts[i]; 
    204202        t = new NikonCodec().decompress(t, options); 
    205203      } 
    206       src.add(t); 
     204      src.write(t); 
    207205    } 
    208206 
    209207    BitBuffer bb = new BitBuffer(src.toByteArray()); 
    210208    short[] pix = new short[getSizeX() * getSizeY() * 3]; 
     209 
     210    src.close(); 
    211211 
    212212    int[] colorMap = new int[4]; 
  • trunk/components/bio-formats/src/loci/formats/in/OMEXMLReader.java

    r4645 r4681  
    2828import loci.common.*; 
    2929import loci.formats.*; 
    30 import loci.formats.codec.Base64Codec; 
    31 import loci.formats.codec.JPEG2000Codec; 
    32 import loci.formats.codec.JPEGCodec; 
    33 import loci.formats.codec.ZlibCodec; 
     30import loci.formats.codec.*; 
    3431import loci.formats.meta.MetadataRetrieve; 
    3532import loci.formats.meta.MetadataStore; 
     
    145142    int planeSize = getSizeX() * getSizeY() * depth; 
    146143 
    147     byte[] pixels = new Base64Codec().decompress(in, new Integer(planeSize)); 
     144    CodecOptions options = new CodecOptions(); 
     145    options.width = getSizeX(); 
     146    options.height = getSizeY(); 
     147    options.bitsPerSample = depth * 8; 
     148    options.channels = getRGBChannelCount(); 
     149    options.maxBytes = planeSize; 
     150    options.littleEndian = isLittleEndian(); 
     151    options.interleaved = isInterleaved(); 
     152 
     153    byte[] pixels = new Base64Codec().decompress(in, options); 
    148154    // TODO: Create a method uncompress to handle all compression methods 
    149155    if (compress.equals("bzip2")) { 
     
    162168    } 
    163169    else if (compress.equals("zlib")) { 
    164       pixels = new ZlibCodec().decompress(pixels, null); 
     170      pixels = new ZlibCodec().decompress(pixels, options); 
    165171    } 
    166172    else if (compress.equals("J2K")) { 
    167       Object[] options = {Boolean.TRUE,Boolean.TRUE,new Long(planeSize)}; 
    168173      pixels = new JPEG2000Codec().decompress(pixels, options); 
    169174    } 
    170175    else if (compress.equals("JPEG")) { 
    171       Object[] options = {Boolean.TRUE,Boolean.TRUE}; 
    172176      pixels = new JPEGCodec().decompress(pixels, options); 
    173177    } 
  • trunk/components/bio-formats/src/loci/formats/in/OpenlabReader.java

    r4666 r4681  
    2828import loci.common.*; 
    2929import loci.formats.*; 
    30 import loci.formats.codec.LZOCodec; 
     30import loci.formats.codec.*; 
    3131import loci.formats.meta.FilterMetadata; 
    3232import loci.formats.meta.MetadataStore; 
     
    151151        int bytes = bpp * getRGBChannelCount(); 
    152152        in.read(b); 
    153         b = new LZOCodec().decompress(b, 
    154           new Integer(getSizeX() * getSizeY() * bytes)); 
     153 
     154        CodecOptions options = new CodecOptions(); 
     155        options.width = getSizeX(); 
     156        options.height = getSizeY(); 
     157        options.bitsPerSample = bytes * 8; 
     158        options.maxBytes = getSizeX() * getSizeY() * bytes; 
     159        b = new LZOCodec().decompress(b, options); 
     160 
    155161        if (getSizeX() * getSizeY() * 4 <= b.length) { 
    156162          for (int yy=y; yy<h + y; yy++) { 
  • trunk/components/bio-formats/src/loci/formats/in/PSDReader.java

    r4648 r4681  
    2727import loci.common.*; 
    2828import loci.formats.*; 
    29 import loci.formats.codec.PackbitsCodec; 
     29import loci.formats.codec.*; 
    3030import loci.formats.meta.FilterMetadata; 
    3131import loci.formats.meta.MetadataStore; 
     
    9797      } 
    9898 
     99      CodecOptions options = new CodecOptions(); 
     100      options.maxBytes = getSizeX() * bpp; 
     101 
     102      int len = w * bpp; 
     103 
    99104      for (int c=0; c<getSizeC(); c++) { 
    100105        for (int row=0; row<getSizeY(); row++) { 
    101106          if (row < y || row >= (y + h)) in.skipBytes(lens[c][row]); 
    102107          else { 
    103             byte[] b = codec.decompress(in, new Integer(getSizeX() * bpp)); 
    104             System.arraycopy(b, x * bpp, buf, 
    105               c * h * bpp * w + (row - y) * bpp * w, w * bpp); 
     108            byte[] b = codec.decompress(in, options); 
     109            System.arraycopy(b, x*bpp, buf, c * h * len + (row - y) * len, len); 
    106110          } 
    107111        } 
  • trunk/components/bio-formats/src/loci/formats/in/PictReader.java

    r4648 r4681  
    2828import loci.common.*; 
    2929import loci.formats.*; 
    30 import loci.formats.codec.PackbitsCodec; 
     30import loci.formats.codec.*; 
    3131import loci.formats.meta.FilterMetadata; 
    3232import loci.formats.meta.MetadataStore; 
     
    488488        else { 
    489489          PackbitsCodec c = new PackbitsCodec(); 
    490           uBuf = c.decompress(buf, new Integer(getSizeX() * 4)); 
     490          CodecOptions options = new CodecOptions(); 
     491          options.maxBytes = getSizeX() * 4; 
     492          uBuf = c.decompress(buf, options); 
    491493        } 
    492494 
  • trunk/components/bio-formats/src/loci/formats/in/QTReader.java

    r4666 r4681  
    675675    throws FormatException, IOException 
    676676  { 
     677    CodecOptions options = new MJPBCodecOptions(); 
     678    options.width = getSizeX(); 
     679    options.height = getSizeY(); 
     680    options.bitsPerSample = bitsPerPixel; 
     681    options.channels = bitsPerPixel < 40 ? bitsPerPixel / 8 : 
     682      (bitsPerPixel - 32) / 8; 
     683    options.previousImage = canUsePrevious ? prevPixels : null; 
     684    options.littleEndian = isLittleEndian(); 
     685    options.interleaved = false; 
     686 
    677687    if (code.equals("raw ")) return pixs; 
    678688    else if (code.equals("rle ")) { 
    679       Object[] options = new Object[2]; 
    680       options[0] = new int[] {getSizeX(), getSizeY(), 
    681         bitsPerPixel < 40 ? bitsPerPixel / 8 : (bitsPerPixel - 32) / 8}; 
    682       options[1] = canUsePrevious ? prevPixels : null; 
    683689      return new QTRLECodec().decompress(pixs, options); 
    684690    } 
    685691    else if (code.equals("rpza")) { 
    686       int[] options = new int[] {getSizeX(), getSizeY()}; 
    687692      return new RPZACodec().decompress(pixs, options); 
    688693    } 
    689694    else if (code.equals("mjpb")) { 
    690       int[] options = new int[4]; 
    691       options[0] = getSizeX(); 
    692       options[1] = getSizeY(); 
    693       options[2] = bitsPerPixel; 
    694       options[3] = interlaced ? 1 : 0; 
     695      ((MJPBCodecOptions) options).interlaced = interlaced; 
    695696      return new MJPBCodec().decompress(pixs, options); 
    696697    } 
    697698    else if (code.equals("jpeg")) { 
    698       return new JPEGCodec().decompress(pixs, new Boolean(isLittleEndian())); 
     699      return new JPEGCodec().decompress(pixs, options); 
    699700    } 
    700701    else throw new FormatException("Unsupported codec : " + code); 
  • trunk/components/bio-formats/src/loci/formats/in/ZeissZVIReader.java

    r4662 r4681  
    3030import loci.common.*; 
    3131import loci.formats.*; 
    32 import loci.formats.codec.JPEGCodec; 
     32import loci.formats.codec.*; 
    3333import loci.formats.meta.*; 
    3434 
     
    9696    int pixel = bytes * getRGBChannelCount(); 
    9797 
     98    CodecOptions options = new CodecOptions(); 
     99    options.littleEndian = isLittleEndian(); 
     100    options.interleaved = isInterleaved(); 
     101 
    98102    if (tileRows * tileColumns == 0 || tileWidth * tileHeight == 0) { 
    99103      RandomAccessStream s = poi.getDocumentStream(imageFiles[no]); 
     
    103107 
    104108      if (isJPEG) { 
    105         byte[] t = new JPEGCodec().decompress(s, new Object[] { 
    106           new Boolean(isLittleEndian()), new Boolean(isInterleaved())}); 
     109        byte[] t = new JPEGCodec().decompress(s, options); 
    107110 
    108111        int row = getSizeX() * pixel; 
     
    156159              s.read(tile); 
    157160              if (isJPEG) { 
    158                 tile = new JPEGCodec().decompress(tile, 
    159                   new Object[] {new Boolean(isLittleEndian()), 
    160                   new Boolean(isInterleaved())}); 
     161                tile = new JPEGCodec().decompress(tile, options); 
    161162              } 
    162163              s.close(); 
  • trunk/components/bio-formats/src/loci/formats/out/JPEG2000Writer.java

    r4550 r4681  
    2929import loci.common.*; 
    3030import loci.formats.*; 
     31import loci.formats.codec.CodecOptions; 
    3132import loci.formats.codec.JPEG2000Codec; 
    3233 
     
    8081 
    8182    out = new RandomAccessFile(currentId, "rw"); 
    82     byte[] compressedData = new JPEG2000Codec().compress(stream, img.getWidth(), 
    83       img.getHeight(), new int[] {img.getRaster().getNumBands(), bytesPerPixel}, 
    84       new Boolean[] {Boolean.TRUE, Boolean.FALSE}); 
     83 
     84    CodecOptions options = new CodecOptions(); 
     85    options.width = img.getWidth(); 
     86    options.height = img.getHeight(); 
     87    options.channels = img.getRaster().getNumBands(); 
     88    options.bitsPerSample = bytesPerPixel * 8; 
     89    options.littleEndian = true; 
     90    options.interleaved = false; 
     91 
     92    byte[] compressedData = new JPEG2000Codec().compress(stream, options); 
    8593    out.write(compressedData); 
    8694    out.close(); 
  • trunk/components/bio-formats/src/loci/formats/out/OMEXMLWriter.java

    r4645 r4681  
    3030import loci.common.*; 
    3131import loci.formats.*; 
    32 import loci.formats.codec.Base64Codec; 
    33 import loci.formats.codec.JPEG2000Codec; 
    34 import loci.formats.codec.JPEGCodec; 
    35 import loci.formats.codec.ZlibCodec; 
     32import loci.formats.codec.*; 
    3633import loci.formats.meta.MetadataRetrieve; 
    3734import org.xml.sax.Attributes; 
     
    9087      initialized = true; 
    9188    } 
    92     boolean littleEndian=!retrieve.getPixelsBigEndian(series, 0).booleanValue(); 
     89    boolean littleEndian = 
     90      !retrieve.getPixelsBigEndian(series, 0).booleanValue(); 
    9391    BufferedImage buffImage=AWTImageTools.makeBuffered(image); 
    94     int width = buffImage.getWidth(); 
    95     int height = buffImage.getHeight(); 
    9692    byte[][] pix = AWTImageTools.getPixelBytes(buffImage, littleEndian); 
    9793    buffImage = null; 
    98     // TODO: Write decompress to use LittleEndian option 
    99     Object[] options = {Boolean.TRUE, Boolean.TRUE}; 
     94 
     95    CodecOptions options = new CodecOptions(); 
     96    options.width = buffImage.getWidth(); 
     97    options.height = buffImage.getHeight(); 
     98    options.channels = 1; 
     99    options.interleaved = false; 
     100    options.littleEndian = littleEndian; 
     101 
    100102    for (int i = 0; i < pix.length; i++) { 
    101103      // TODO: Create a method compress to handle all compression methods 
    102       int bytes = pix[i].length / (width * height); 
    103       int[] dims = new int[] {1, bytes}; // one channels compressed at a time 
     104      int bytes = pix[i].length / (options.width * options.height); 
     105      options.bitsPerSample = bytes * 8; 
     106 
    104107      if (compression.equals("J2K")) { 
    105         pix[i] = new JPEG2000Codec().compress(pix[i], width, height, 
    106           dims, options); 
     108        pix[i] = new JPEG2000Codec().compress(pix[i], options); 
    107109      } 
    108110      else if (compression.equals("JPEG")) { 
    109         pix[i] = new JPEGCodec().compress(pix[i], width, height, 
    110           dims, options); 
     111        pix[i] = new JPEGCodec().compress(pix[i], options); 
    111112      } 
    112113      else if (compression.equals("zlib")) { 
    113         pix[i] = new ZlibCodec().compress(pix[i], 0, 0, null, null); 
     114        pix[i] = new ZlibCodec().compress(pix[i], options); 
    114115      } 
    115       byte[] encodedPix = new Base64Codec().compress(pix[i], 0, 0, null, null); 
     116      byte[] encodedPix = new Base64Codec().compress(pix[i], options); 
    116117 
    117118      StringBuffer plane = new StringBuffer("\n<Bin:BinData Length=\""); 
Note: See TracChangeset for help on using the changeset viewer.