Changeset 2531


Ignore:
Timestamp:
04/02/07 11:33:33 (13 years ago)
Author:
curtis
Message:

Remove unnecessary small array allocations from IFD parsing logic.

File:
1 edited

Legend:

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

    r2493 r2531  
    400400      if (type == BYTE) { 
    401401        // 8-bit unsigned integer 
    402         short[] bytes = new short[count]; 
    403402        if (count > 4) { 
    404403          long pointer = in.readInt(); 
    405404          in.seek((int) pointer); 
    406405        } 
    407         for (int j=0; j<count; j++) { 
    408           bytes[j] = (byte) in.read(); 
    409           if (bytes[j] < 0) bytes[j] += 255; 
    410         } 
    411         if (bytes.length == 1) value = new Short(bytes[0]); 
    412         else value = bytes; 
     406        if (count == 1) value = new Short((byte) in.read()); 
     407        else { 
     408          short[] bytes = new short[count]; 
     409          for (int j=0; j<count; j++) { 
     410            bytes[j] = (byte) in.read(); 
     411            if (bytes[j] < 0) bytes[j] += 255; 
     412          } 
     413          value = bytes; 
     414        } 
    413415      } 
    414416      else if (type == ASCII) { 
     
    429431 
    430432        // convert character array to array of strings 
    431         String[] strings = new String[nullCount]; 
     433        String[] strings = count == 1 ? null : new String[nullCount]; 
     434        String s = null; 
    432435        int c = 0, ndx = -1; 
    433436        for (int j=0; j<count; j++) { 
    434437          if (ascii[j] == 0) { 
    435             strings[c++] = new String(ascii, ndx + 1, j - ndx - 1); 
     438            s = new String(ascii, ndx + 1, j - ndx - 1); 
    436439            ndx = j; 
    437440          } 
    438441          else if (j == count - 1) { 
    439442            // handle non-null-terminated strings 
    440             strings[c++] = new String(ascii, ndx + 1, j - ndx); 
    441           } 
    442         } 
    443         if (strings.length == 1) value = strings[0]; 
    444         else value = strings; 
     443            s = new String(ascii, ndx + 1, j - ndx); 
     444          } 
     445          if (count > 1) strings[c++] = s; 
     446        } 
     447        if (count == 1) value = strings[0]; 
     448        else value = s; 
    445449      } 
    446450      else if (type == SHORT) { 
    447451        // 16-bit (2-byte) unsigned integer 
    448         int[] shorts = new int[count]; 
    449452        if (count > 2) { 
    450453          long pointer = in.readInt(); 
    451454          in.seek((int) pointer); 
    452455        } 
    453         for (int j=0; j<count; j++) { 
    454           shorts[j] = in.readShort(); 
    455           if (shorts[j] < 0) shorts[j] += 65536; 
    456         } 
    457         if (shorts.length == 1) value = new Integer(shorts[0]); 
    458         else value = shorts; 
     456        if (count == 1) value = new Integer(in.readShort()); 
     457        else { 
     458          int[] shorts = new int[count]; 
     459          for (int j=0; j<count; j++) { 
     460            shorts[j] = in.readShort(); 
     461            if (shorts[j] < 0) shorts[j] += 65536; 
     462          } 
     463          value = shorts; 
     464        } 
    459465      } 
    460466      else if (type == LONG) { 
    461467        // 32-bit (4-byte) unsigned integer 
    462         long[] longs = new long[count]; 
    463468        if (count > 1) { 
    464469          long pointer = in.readInt(); 
    465470          in.seek((int) pointer); 
    466471        } 
    467         for (int j=0; j<count; j++) { 
    468           longs[j] = in.readInt(); 
    469         } 
    470         if (longs.length == 1) value = new Long(longs[0]); 
    471         else value = longs; 
    472       } 
    473       else if (type == RATIONAL) { 
     472        if (count == 1) value = new Long(in.readInt()); 
     473        else { 
     474          long[] longs = new long[count]; 
     475          for (int j=0; j<count; j++) longs[j] = in.readInt(); 
     476          value = longs; 
     477        } 
     478      } 
     479      else if (type == RATIONAL || type == SRATIONAL) { 
    474480        // Two LONGs: the first represents the numerator of a fraction; 
    475481        // the second, the denominator 
    476         TiffRational[] rationals = new TiffRational[count]; 
     482        // Two SLONG's: the first represents the numerator of a fraction, 
     483        // the second the denominator 
    477484        long pointer = in.readInt(); 
    478485        in.seek((int) pointer); 
    479         for (int j=0; j<count; j++) { 
    480           long numer = in.readInt(); 
    481           long denom = in.readInt(); 
    482           rationals[j] = new TiffRational(numer, denom); 
    483         } 
    484         if (rationals.length == 1) value = rationals[0]; 
    485         else value = rationals; 
     486        if (count == 1) value = new TiffRational(in.readInt(), in.readInt()); 
     487        else { 
     488          TiffRational[] rationals = new TiffRational[count]; 
     489          for (int j=0; j<count; j++) { 
     490            rationals[j] = new TiffRational(in.readInt(), in.readInt()); 
     491          } 
     492          value = rationals; 
     493        } 
    486494      } 
    487495      else if (type == SBYTE || type == UNDEFINED) { 
     
    489497        // UNDEFINED: An 8-bit byte that may contain anything, 
    490498        // depending on the definition of the field 
    491         byte[] sbytes = new byte[count]; 
    492499        if (count > 4) { 
    493500          long pointer = in.readInt(); 
    494501          in.seek((int) pointer); 
    495502        } 
    496         in.read(sbytes); 
    497         if (sbytes.length == 1) value = new Byte(sbytes[0]); 
    498         else value = sbytes; 
     503        if (count == 1) value = new Byte((byte) in.read()); 
     504        else { 
     505          byte[] sbytes = new byte[count]; 
     506          in.readFully(sbytes); 
     507          value = sbytes; 
     508        } 
    499509      } 
    500510      else if (type == SSHORT) { 
    501511        // A 16-bit (2-byte) signed (twos-complement) integer 
    502         short[] sshorts = new short[count]; 
    503512        if (count > 2) { 
    504513          long pointer = in.readInt(); 
    505514          in.seek((int) pointer); 
    506515        } 
    507         for (int j=0; j<count; j++) { 
    508           sshorts[j] = in.readShort(); 
    509         } 
    510         if (sshorts.length == 1) value = new Short(sshorts[0]); 
    511         else value = sshorts; 
     516        if (count == 1) value = new Short(in.readShort()); 
     517        else { 
     518          short[] sshorts = new short[count]; 
     519          for (int j=0; j<count; j++) sshorts[j] = in.readShort(); 
     520          value = sshorts; 
     521        } 
    512522      } 
    513523      else if (type == SLONG) { 
    514524        // A 32-bit (4-byte) signed (twos-complement) integer 
    515         int[] slongs = new int[count]; 
    516525        if (count > 1) { 
    517526          long pointer = in.readInt(); 
    518527          in.seek((int) pointer); 
    519528        } 
    520         for (int j=0; j<count; j++) { 
    521           slongs[j] = in.readInt(); 
    522         } 
    523         if (slongs.length == 1) value = new Integer(slongs[0]); 
    524         else value = slongs; 
    525       } 
    526       else if (type == SRATIONAL) { 
    527         // Two SLONG's: the first represents the numerator of a fraction, 
    528         // the second the denominator 
    529         TiffRational[] srationals = new TiffRational[count]; 
    530         long pointer = in.readInt(); 
    531         in.seek((int) pointer); 
    532         for (int j=0; j<count; j++) { 
    533           int numer = in.readInt(); 
    534           int denom = in.readInt(); 
    535           srationals[j] = new TiffRational(numer, denom); 
    536         } 
    537         if (srationals.length == 1) value = srationals[0]; 
    538         else value = srationals; 
     529        if (count == 1) value = new Integer(in.readInt()); 
     530        else { 
     531          int[] slongs = new int[count]; 
     532          for (int j=0; j<count; j++) slongs[j] = in.readInt(); 
     533          value = slongs; 
     534        } 
    539535      } 
    540536      else if (type == FLOAT) { 
    541537        // Single precision (4-byte) IEEE format 
    542         float[] floats = new float[count]; 
    543538        if (count > 1) { 
    544539          long pointer = in.readInt(); 
    545540          in.seek((int) pointer); 
    546541        } 
    547         for (int j=0; j<count; j++) { 
    548           floats[j] = in.readFloat(); 
    549         } 
    550         if (floats.length == 1) value = new Float(floats[0]); 
    551         else value = floats; 
     542        if (count == 1) value = new Float(in.readFloat()); 
     543        else { 
     544          float[] floats = new float[count]; 
     545          for (int j=0; j<count; j++) floats[j] = in.readFloat(); 
     546          value = floats; 
     547        } 
    552548      } 
    553549      else if (type == DOUBLE) { 
    554550        // Double precision (8-byte) IEEE format 
    555         double[] doubles = new double[count]; 
    556551        long pointer = in.readInt(); 
    557552        in.seek((int) pointer); 
    558         for (int j=0; j<count; j++) { 
    559           doubles[j] = in.readDouble(); 
    560         } 
    561         if (doubles.length == 1) value = new Double(doubles[0]); 
    562         else value = doubles; 
     553        if (count == 1) value = new Double(in.readDouble()); 
     554        else { 
     555          double[] doubles = new double[count]; 
     556          for (int j=0; j<count; j++) { 
     557            doubles[j] = in.readDouble(); 
     558          } 
     559          value = doubles; 
     560        } 
    563561      } 
    564562      if (value != null) ifd.put(new Integer(tag), value); 
Note: See TracChangeset for help on using the changeset viewer.