Changeset 4666


Ignore:
Timestamp:
12/02/08 11:27:44 (11 years ago)
Author:
melissa
Message:

Fixed a handful of bugs exposed by the test suite.

Location:
trunk/components/bio-formats/src/loci/formats
Files:
5 edited

Legend:

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

    r4521 r4666  
    2525 
    2626import java.io.IOException; 
    27 import loci.common.RandomAccessStream; 
    28 import loci.formats.FormatException; 
     27import loci.common.*; 
     28import loci.formats.*; 
    2929 
    3030/** 
     
    4848    throws FormatException, IOException 
    4949  { 
     50    byte[] b = new byte[(int) (in.length() - in.getFilePointer())]; 
     51    in.read(b); 
     52    return decompress(b, options); 
     53  } 
     54 
     55  /* @see Codec#decompress(byte[], Object) */ 
     56  public byte[] decompress(byte[] data, Object options) throws FormatException { 
    5057    if (options == null || !(options instanceof Object[])) return null; 
    5158 
     
    5865    int numLines = y; 
    5966 
    60     if (in.length() - in.getFilePointer() < 8) return prev; 
     67    if (data.length < 8) return prev; 
    6168 
    62     in.skipBytes(4); 
     69    int line = x * bpp; 
    6370 
    64     int header = in.readShort(); 
    65     int off = 0; 
    66     int start = 0; 
     71    try { 
     72      RABytes s = new RABytes(data); 
     73      s.skipBytes(4); 
    6774 
    68     byte[] output = new byte[x * y * bpp]; 
     75      int header = s.readShort(); 
     76      int off = 0; 
     77      int start = 0; 
    6978 
    70     if ((header & 8) == 8) { 
    71       start = in.readShort(); 
    72       in.skipBytes(2); 
    73       numLines = in.readShort(); 
    74       in.skipBytes(2); 
     79      byte[] output = new byte[y * line]; 
    7580 
    76       if (prev != null) { 
    77         for (int i=0; i<start; i++) { 
    78           off = i * x * bpp; 
    79           System.arraycopy(prev, off, output, off, x * bpp); 
     81      if ((header & 8) == 8) { 
     82        start = s.readShort(); 
     83        s.skipBytes(2); 
     84        numLines = s.readShort(); 
     85        s.skipBytes(2); 
     86 
     87        if (prev != null) { 
     88          for (int i=0; i<start; i++) { 
     89            System.arraycopy(prev, off, output, off, line); 
     90            off += line; 
     91          } 
     92        } 
     93 
     94        if (prev != null) { 
     95          off = line * (start + numLines); 
     96          for (int i=start+numLines; i<y; i++) { 
     97            System.arraycopy(prev, off, output, off, line); 
     98            off += line; 
     99          } 
    80100        } 
    81101      } 
    82       off += x * bpp; 
     102      else throw new FormatException("Unsupported header : " + header); 
    83103 
    84       if (prev != null) { 
    85         for (int i=start+numLines; i<y; i++) { 
    86           int offset = i * x * bpp; 
    87           System.arraycopy(prev, offset, output, offset, x * bpp); 
     104      // uncompress remaining lines 
     105 
     106      int skip = 0; // number of bytes to skip 
     107      byte rle = 0; // RLE code 
     108 
     109      int rowPointer = start * line; 
     110 
     111      for (int i=0; i<numLines; i++) { 
     112        skip = s.read(); 
     113        if (skip < 0) skip += 256; 
     114 
     115        if (prev != null) { 
     116          try { 
     117            System.arraycopy(prev, rowPointer, output, rowPointer, 
     118              (skip - 1) * bpp); 
     119          } 
     120          catch (ArrayIndexOutOfBoundsException e) { } 
    88121        } 
     122 
     123        off = rowPointer + ((skip - 1) * bpp); 
     124        while (true) { 
     125          rle = (byte) (s.read() & 0xff); 
     126 
     127          if (rle == 0) { 
     128            skip = s.read(); 
     129 
     130            if (prev != null) { 
     131              try { 
     132                System.arraycopy(prev, off, output, off, (skip - 1) * bpp); 
     133              } 
     134              catch (ArrayIndexOutOfBoundsException e) { } 
     135            } 
     136 
     137            off += (skip - 1) * bpp; 
     138          } 
     139          else if (rle == -1) { 
     140            if (off < (rowPointer + line) && prev != null) { 
     141              System.arraycopy(prev, off, output, off, rowPointer + line - off); 
     142            } 
     143            break; 
     144          } 
     145          else if (rle < -1) { 
     146            // unpack next pixel and copy it to output -(rle) times 
     147            for (int j=0; j<(-1*rle); j++) { 
     148              if (off < output.length) { 
     149                System.arraycopy(data, (int) s.getFilePointer(), output, 
     150                  off, bpp); 
     151                off += bpp; 
     152              } 
     153              else break; 
     154            } 
     155            s.skipBytes(bpp); 
     156          } 
     157          else { 
     158            // copy (rle) pixels to output 
     159            int len = rle * bpp; 
     160            if (output.length - off < len) len = output.length - off; 
     161            if (s.length() - s.getFilePointer() < len) { 
     162              len = (int) (s.length() - s.getFilePointer()); 
     163            } 
     164            if (len < 0) len = 0; 
     165            if (off > output.length) off = output.length; 
     166            s.read(output, off, len); 
     167            off += len; 
     168          } 
     169          if (s.getFilePointer() >= s.length()) return output; 
     170        } 
     171        rowPointer += line; 
    89172      } 
     173      return output; 
    90174    } 
    91     else throw new FormatException("Unsupported header : " + header); 
     175    catch (IOException e) { 
     176      throw new FormatException(e); 
     177    } 
     178  } 
    92179 
    93     // uncompress remaining lines 
    94  
    95     int skip = 0; // number of bytes to skip 
    96     byte rle = 0; // RLE code 
    97  
    98     int rowPointer = start * x * bpp; 
    99  
    100     for (int i=0; i<numLines; i++) { 
    101       skip = in.read() & 0xff; 
    102  
    103       if (prev != null) { 
    104         try { 
    105           System.arraycopy(prev, rowPointer, output, rowPointer, 
    106             (skip - 1) * bpp); 
    107         } 
    108         catch (ArrayIndexOutOfBoundsException e) { } 
    109       } 
    110  
    111       off = rowPointer + ((skip - 1) * bpp); 
    112       while (true) { 
    113         rle = (byte) (in.read() & 0xff); 
    114  
    115         if (rle == 0) { 
    116           skip = in.read(); 
    117  
    118           if (prev != null) { 
    119             try { 
    120               System.arraycopy(prev, off, output, off, (skip - 1) * bpp); 
    121             } 
    122             catch (ArrayIndexOutOfBoundsException e) { } 
    123           } 
    124  
    125           off += (skip - 1) * bpp; 
    126         } 
    127         else if (rle == -1) { 
    128           if (off < (rowPointer + (x * bpp)) && prev != null) { 
    129             System.arraycopy(prev, off, output, off, rowPointer + 
    130               (x * bpp) - off); 
    131           } 
    132           break; 
    133         } 
    134         else if (rle < -1) { 
    135           // unpack next pixel and copy it to output -(rle) times 
    136           in.read(output, off, bpp); 
    137           for (int j=1; j<(-1*rle); j++) { 
    138             if (off < output.length) { 
    139               System.arraycopy(output, off, output, off + bpp, bpp); 
    140               off += bpp; 
    141             } 
    142             else break; 
    143           } 
    144         } 
    145         else { 
    146           // copy (rle) pixels to output 
    147           int len = rle * bpp; 
    148           len = (int) Math.min(len, output.length - off); 
    149           len = 
    150             (int) Math.min(len, (int) (in.length() - in.getFilePointer())); 
    151           if (len < 0) len = 0; 
    152           if (off > output.length) off = output.length; 
    153           in.read(output, off, len); 
    154           off += len; 
    155         } 
    156         if (in.getFilePointer() >= in.length()) return output; 
    157       } 
    158       rowPointer += x * bpp; 
    159     } 
    160     return output; 
    161   } 
    162180} 
  • trunk/components/bio-formats/src/loci/formats/codec/RPZACodec.java

    r4521 r4666  
    7777    totalBlocks = ((x + 3) / 4) * ((y + 3) / 4); 
    7878 
    79     while (in.getFilePointer() < in.length()) { 
     79    while (in.getFilePointer() + 2 < in.length()) { 
    8080      opcode = in.readByte(); 
    8181      nBlocks = (opcode & 0x1f) + 1; 
     
    105105          break; 
    106106        case 0xa0: 
     107          if (in.getFilePointer() + 2 >= in.length()) break; 
    107108          colorA = in.readShort(); 
    108109          while (nBlocks-- > 0) { 
     
    129130        case 0xc0: 
    130131        case 0x20: 
     132          if (in.getFilePointer() + 2 >= in.length()) break; 
    131133          if ((opcode & 0xe0) == 0xc0) { 
    132134            colorA = in.readShort(); 
     
    184186            for (pixelX=0; pixelX<4; pixelX++) { 
    185187              if ((pixelY != 0) || (pixelX != 0)) { 
     188                if (in.getFilePointer() + 2 >= in.length()) break; 
    186189                colorA = in.readShort(); 
    187190              } 
  • trunk/components/bio-formats/src/loci/formats/in/OpenlabReader.java

    r4655 r4666  
    569569    store.setImageInstrumentRef("Instrument:0", 0); 
    570570 
    571     if (gain != null) store.setDetectorSettingsGain(new Float(gain), 0, 0); 
    572     if (detectorOffset != null) { 
    573       store.setDetectorSettingsOffset(new Float(detectorOffset), 0, 0); 
    574     } 
     571    try { 
     572      if (gain != null) store.setDetectorSettingsGain(new Float(gain), 0, 0); 
     573    } 
     574    catch (NumberFormatException e) { } 
     575    try { 
     576      if (detectorOffset != null) { 
     577        store.setDetectorSettingsOffset(new Float(detectorOffset), 0, 0); 
     578      } 
     579    } 
     580    catch (NumberFormatException e) { } 
    575581 
    576582    // link DetectorSettings to an actual Detector 
  • trunk/components/bio-formats/src/loci/formats/in/QTReader.java

    r4648 r4666  
    282282      t = new byte[prevPixels.length - getSizeY()*pad]; 
    283283 
     284      int bytes = bitsPerPixel < 40 ? bitsPerPixel / 8 : 
     285        (bitsPerPixel - 32) / 8; 
     286 
    284287      for (int row=0; row<getSizeY(); row++) { 
    285         System.arraycopy(prevPixels, row*(getSizeX() + pad), t, 
    286           row*getSizeX(), getSizeX()); 
     288        System.arraycopy(prevPixels, bytes * row * (getSizeX() + pad), t, 
     289          row * getSizeX() * bytes, getSizeX()); 
    287290      } 
    288291    } 
     
    294297      if (bitsPerPixel == 32) { 
    295298        for (int col=0; col<w; col++) { 
    296           System.arraycopy(t, row*getSizeX()*bpp*4 + (x + col)*bpp*4 + 1, 
    297             buf, row*destRowLen + col*bpp*3, 3); 
     299          int src = row * getSizeX() * bpp * 4 + (x + col) * bpp * 4 + 1; 
     300          int dst = row * destRowLen + col * bpp * 3; 
     301          if (src + 3 <= t.length && dst + 3 <= buf.length) { 
     302            System.arraycopy(t, src, buf, dst, 3); 
     303          } 
    298304        } 
    299305      } 
  • trunk/components/bio-formats/src/loci/formats/in/TCSReader.java

    r4655 r4666  
    9898      return false; 
    9999    } 
     100  } 
     101 
     102  /* @see loci.formats.IFormatReader#fileGroupOption(String) */ 
     103  public int fileGroupOption(String id) throws FormatException, IOException { 
     104    return MUST_GROUP; 
    100105  } 
    101106 
     
    406411      } 
    407412      core = tiffReaders[0].getCoreMetadata(); 
     413 
     414      MetadataStore store = 
     415        new FilterMetadata(getMetadataStore(), isMetadataFiltered()); 
     416      MetadataTools.populatePixels(store, this, true); 
    408417    } 
    409418  } 
Note: See TracChangeset for help on using the changeset viewer.