Changeset 3279


Ignore:
Timestamp:
10/16/07 11:10:26 (12 years ago)
Author:
melissa
Message:
  • Added new API method to loci.formats.codec.Codec to allow decompressing directly from RandomAccessStream.
  • Lots of DICOM fixes.
Location:
trunk/loci/formats
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/formats/TiffTools.java

    r3272 r3279  
    12921292    if (bitsPerSample[0] == 16) littleEndian = !littleEndian; 
    12931293 
     1294    // number of uncompressed bytes in a strip 
     1295    int size = (int) 
     1296      (imageWidth * (bitsPerSample[0] / 8) * rowsPerStrip * samplesPerPixel); 
     1297 
    12941298    if (isTiled) { 
    12951299      long tileWidth = getIFDLongValue(ifd, TILE_WIDTH, true, 0); 
     
    13091313        in.read(b); 
    13101314 
    1311         b = uncompress(b, compression); 
     1315        b = uncompress(b, compression, data.length); 
    13121316 
    13131317        int ext = (int) (b.length / (tileWidth * tileLength)); 
     
    13531357          in.read(bytes); 
    13541358          if (compression != PACK_BITS) { 
    1355             bytes = uncompress(bytes, compression); 
     1359            bytes = uncompress(bytes, compression, size); 
    13561360            undifference(bytes, bitsPerSample, 
    13571361              imageWidth, planarConfig, predictor); 
     
    13961400    // only do this if the image uses PackBits compression 
    13971401    if (altBytes.length != 0) { 
    1398       altBytes = uncompress(altBytes, compression); 
     1402      altBytes = uncompress(altBytes, compression, size); 
    13991403      undifference(altBytes, bitsPerSample, 
    14001404        imageWidth, planarConfig, predictor); 
     
    18361840 
    18371841  /** Decodes a strip of data compressed with the given compression scheme. */ 
    1838   public static byte[] uncompress(byte[] input, int compression) 
     1842  public static byte[] uncompress(byte[] input, int compression, int size) 
    18391843    throws FormatException, IOException 
    18401844  { 
     
    18621866    } 
    18631867    else if (compression == PACK_BITS) { 
    1864       return new PackbitsCodec().decompress(input); 
     1868      return new PackbitsCodec().decompress(input, new Integer(size)); 
    18651869    } 
    18661870    else if (compression == PROPRIETARY_DEFLATE || compression == DEFLATE) { 
  • trunk/loci/formats/codec/BaseCodec.java

    r3015 r3279  
    2525package loci.formats.codec; 
    2626 
     27import java.io.IOException; 
    2728import java.util.*; 
    2829import loci.formats.FormatException; 
    2930import loci.formats.LogTools; 
     31import loci.formats.RandomAccessStream; 
    3032 
    3133/** 
     
    158160  } 
    159161 
     162  /* @see Codec#decompress(byte[], Object) */ 
     163  public byte[] decompress(byte[] data, Object options) throws FormatException 
     164  { 
     165    try { 
     166      return decompress(new RandomAccessStream(data), options); 
     167    } 
     168    catch (IOException exc) { 
     169      throw new FormatException(exc); 
     170    } 
     171  } 
     172 
     173  /* @see Codec#decompress(RandomAccessStream, Object) */ 
     174  public byte[] decompress(RandomAccessStream in, Object options) 
     175    throws FormatException 
     176  { 
     177    try { 
     178      byte[] b = new byte[(int) in.length()]; 
     179      in.read(b); 
     180      return decompress(b, options); 
     181    } 
     182    catch (IOException exc) { throw new FormatException(exc); } 
     183  } 
     184 
    160185  /** 
    161186   * 2D data block decoding default implementation. 
  • trunk/loci/formats/codec/Codec.java

    r3015 r3279  
    2626 
    2727import loci.formats.FormatException; 
     28import loci.formats.RandomAccessStream; 
    2829 
    2930/** 
     
    120121  byte[] decompress(byte[][] data) throws FormatException; 
    121122 
     123  /** 
     124   * Decompresses data from the given RandomAccessStream. 
     125   * 
     126   * @param in The stream from which to read compressed data. 
     127   * @param options Options to be used during decompression. 
     128   * @return The decompressed data. 
     129   * @throws FormatException If data is not valid compressed data for this 
     130   *   decompressor. 
     131   */ 
     132  byte[] decompress(RandomAccessStream in, Object options) 
     133    throws FormatException; 
     134 
     135 
     136 
    122137} 
  • trunk/loci/formats/codec/JPEGCodec.java

    r3015 r3279  
    6161   * Decodes an image strip using JPEG compression algorithm. 
    6262   * 
    63    * @param input input data to be decompressed 
     63   * @param in The stream from which to read compressed data. 
    6464   * @return The decompressed data 
    6565   * @throws FormatException if data is not valid compressed data for this 
    6666   *                         decompressor 
    6767   */ 
    68   public byte[] decompress(byte[] input, Object options) throws FormatException 
     68  public byte[] decompress(RandomAccessStream in, Object options) 
     69    throws FormatException 
    6970  { 
    7071    BufferedImage b; 
    7172    try { 
    72       RandomAccessStream s = new RandomAccessStream(input); 
    73       while (s.read() != (byte) 0xff || s.read() != (byte) 0xd8); 
    74       int offset = (int) s.getFilePointer() - 2; 
    75       b = ImageIO.read(new BufferedInputStream(new ByteArrayInputStream(input, 
    76         offset, input.length - offset))); 
     73      while (in.read() != (byte) 0xff || in.read() != (byte) 0xd8); 
     74      in.seek(in.getFilePointer() - 2); 
     75      b = ImageIO.read(new BufferedInputStream(in)); 
    7776    } 
    7877    catch (IOException exc) { 
  • trunk/loci/formats/codec/PackbitsCodec.java

    r3015 r3279  
    2525package loci.formats.codec; 
    2626 
     27import java.io.IOException; 
    2728import loci.formats.FormatException; 
     29import loci.formats.RandomAccessStream; 
    2830 
    2931/** 
     
    6668   *                         decompressor 
    6769   */ 
    68   public byte[] decompress(byte[] input, Object options) throws FormatException 
     70  public byte[] decompress(RandomAccessStream in, Object options) 
     71    throws FormatException 
    6972  { 
    70     ByteVector output = new ByteVector(input.length); 
    71     int pt = 0; 
    72     while (pt < input.length) { 
    73       byte n = input[pt++]; 
    74       if (n >= 0) { // 0 <= n <= 127 
    75         int len = pt + n + 1 > input.length ? (input.length - pt) : (n + 1); 
    76         output.add(input, pt, len); 
    77         pt += len; 
     73    int expected = ((Integer) options).intValue(); 
     74    ByteVector output = new ByteVector(1024); 
     75    try { 
     76      while (output.size() < expected) { 
     77        byte n = in.readByte(); 
     78        if (n >= 0) { // 0 <= n <= 127 
     79          for (int i=0; i<n + 1; i++) { 
     80            output.add(in.readByte()); 
     81          } 
     82        } 
     83        else if (n != -128) { // -127 <= n <= -1 
     84          int len = -n + 1; 
     85          byte inp = in.readByte(); 
     86          for (int i=0; i<len; i++) output.add(inp); 
     87        } 
    7888      } 
    79       else if (n != -128) { // -127 <= n <= -1 
    80         if (pt >= input.length) break; 
    81         int len = -n + 1; 
    82         byte inp = input[pt++]; 
    83         for (int i=0; i<len; i++) output.add(inp); 
    84       } 
     89    } 
     90    catch (IOException exc) { 
     91      throw new FormatException(exc); 
    8592    } 
    8693    return output.toByteArray(); 
  • trunk/loci/formats/in/DicomReader.java

    r3197 r3279  
    2525package loci.formats.in; 
    2626 
     27import java.awt.image.BufferedImage; 
    2728import java.io.*; 
    2829import java.text.*; 
    2930import java.util.*; 
     31import javax.imageio.spi.*; 
     32import javax.imageio.stream.MemoryCacheImageInputStream; 
    3033import loci.formats.*; 
    3134import loci.formats.codec.*; 
     
    8285  protected int bitsPerPixel; 
    8386 
    84   /** Offset to first plane. */ 
    85   protected int offsets; 
    86  
    8787  private int location; 
    8888  private int elementLength; 
     
    9292  private boolean bigEndianTransferSyntax; 
    9393  private byte[][] lut; 
     94  private long[] offsets; 
    9495 
    9596  private boolean isJPEG = false; 
     
    101102  // "Digital Imaging and Communications in Medicine" is nasty long. 
    102103  public DicomReader() { 
    103     super("Digital Img. & Comm. in Med.", new String[] {"dcm", "dicom"}); 
     104    super("Digital Img. & Comm. in Med.", new String[] {"dic", "dcm", "dicom"}); 
    104105  } 
    105106 
     
    128129      FormatTools.getBytesPerPixel(core.pixelType[0]) * 
    129130      (isIndexed() ? 1 : core.sizeC[0]); 
    130     in.seek(offsets + bytes * no); 
    131     if (isRLE) { 
    132       in.skipBytes(67); 
    133       while (in.read() == 0); 
    134       in.seek(in.getFilePointer() - 1); 
    135     } 
     131    in.seek(offsets[no]); 
    136132    in.read(buf); 
    137133 
    138134    if (isRLE) { 
    139135      PackbitsCodec codec = new PackbitsCodec(); 
    140       buf = codec.decompress(buf); 
     136      byte[] t = codec.decompress(buf, new Integer(bytes)); 
     137      Arrays.fill(buf, (byte) 0); 
     138      System.arraycopy(t, 0, buf, 0, 
     139        buf.length < t.length ? buf.length : t.length); 
    141140 
    142141      int b = FormatTools.getBytesPerPixel(core.pixelType[0]); 
     
    196195 
    197196    status("Reading tags"); 
     197 
     198    long baseOffset = 0; 
    198199 
    199200    boolean decodingTags = true; 
     
    240241          break; 
    241242        case PLANAR_CONFIGURATION: 
    242           addInfo(tag, in.readShort()); 
     243          short config = in.readShort(); 
     244          if (config == 0) core.interleaved[0] = true; 
     245          addInfo(tag, config); 
    243246          break; 
    244247        case ROWS: 
     
    263266          addInfo(tag, in.readShort()); 
    264267          break; 
     268        case 537262910: 
    265269        case WINDOW_CENTER: 
    266270        case WINDOW_WIDTH: 
     
    271275        case PIXEL_DATA: 
    272276          if (elementLength != 0) { 
    273             offsets = (int) in.getFilePointer(); 
     277            baseOffset = in.getFilePointer(); 
    274278            addInfo(tag, location); 
    275279            decodingTags = false; 
     
    279283        case 0x7f880010: 
    280284          if (elementLength != 0) { 
    281             offsets = location + 4; 
     285            baseOffset = location + 4; 
    282286            decodingTags = false; 
    283287          } 
     
    292296    if (core.imageCount[0] == 0) core.imageCount[0] = 1; 
    293297 
     298    int plane = core.sizeX[0] * core.sizeY[0] * 
     299      (lut == null ? core.sizeC[0] : 1) * 
     300      FormatTools.getBytesPerPixel(core.pixelType[0]); 
     301 
     302    status("Calculating image offsets"); 
     303 
     304    offsets = new long[core.imageCount[0]]; 
     305    for (int i=0; i<core.imageCount[0]; i++) { 
     306      if (isRLE) { 
     307        if (i == 0) in.seek(baseOffset); 
     308        else { 
     309          in.seek(offsets[i - 1]); 
     310          new PackbitsCodec().decompress(in, new Integer(plane)); 
     311        } 
     312        in.skipBytes(67); 
     313        while (in.read() == 0); 
     314        offsets[i] = in.getFilePointer() - 1; 
     315      } 
     316      else if (isJPEG) { 
     317        if (i == 0) offsets[i] = baseOffset; 
     318        else { 
     319          in.seek(offsets[i - 1]); 
     320          new JPEGCodec().decompress(in, null); 
     321          offsets[i] = in.getFilePointer(); 
     322        } 
     323      } 
     324      else offsets[i] = baseOffset + plane*i; 
     325    } 
     326 
    294327    status("Populating metadata"); 
    295328 
     
    299332    core.sizeT[0] = 1; 
    300333    core.currentOrder[0] = "XYCZT"; 
    301     core.interleaved[0] = !(isJPEG || isRLE); 
     334    //core.interleaved[0] = core.interleaved[0] || !(isJPEG || isRLE); 
    302335    core.metadataComplete[0] = true; 
    303336    core.falseColor[0] = false; 
     
    381414        int ndx = color.equals("Red") ? 0 : color.equals("Green") ? 1 : 2; 
    382415        long fp = in.getFilePointer(); 
    383         in.seek(oldFp + ndx*ndx); 
     416        in.seek(oldFp + 1); 
    384417        lut[ndx] = new byte[elementLength / 2]; 
    385418        for (int i=0; i<lut[ndx].length; i++) { 
     
    526559      default: 
    527560        vr = IMPLICIT_VR; 
    528         if (core.littleEndian[0]) { 
    529           return (b[3] << 24) + (b[2] << 16) + (b[1] << 8) + b[0]; 
    530         } 
    531         return (b[0] << 24) + (b[1] << 16) + (b[2] << 8) + b[3]; 
     561        return DataTools.bytesToInt(b, core.littleEndian[0]); 
    532562    } 
    533563  } 
  • trunk/loci/formats/in/PSDReader.java

    r3216 r3279  
    9595          byte[] b = new byte[lens[c][y]]; 
    9696          in.read(b); 
    97           b = codec.decompress(b); 
     97          b = codec.decompress(b, new Integer(core.sizeX[0] * 
     98            FormatTools.getBytesPerPixel(core.pixelType[0]))); 
    9899          System.arraycopy(b, 0, buf, pt, b.length); 
    99100          pt += b.length; 
  • trunk/loci/formats/in/PictReader.java

    r3197 r3279  
    496496 
    497497        PackbitsCodec c = new PackbitsCodec(); 
    498         uBuf = c.decompress(buf); 
    499         //uBuf = Compression.packBitsUncompress(buf); 
     498        uBuf = c.decompress(buf, new Integer(core.sizeX[0] * core.sizeY[0])); 
    500499 
    501500        // invert the pixels -- PICT images map zero to white 
     
    690689        else { 
    691690          PackbitsCodec c = new PackbitsCodec(); 
    692           uBuf = c.decompress(buf); 
    693           //uBuf = Compression.packBitsUncompress(buf); 
     691          uBuf = c.decompress(buf, new Integer(core.sizeX[0] * core.sizeY[0])); 
    694692        } 
    695693 
Note: See TracChangeset for help on using the changeset viewer.