Changeset 3914


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

Removed special unpacking logic for PackBits-compressed planes. I have no idea why this logic was written in the first place.

File:
1 edited

Legend:

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

    r3912 r3914  
    12981298    } 
    12991299 
    1300     byte[] altBytes = new byte[0]; 
    1301  
    13021300    byte[] jpegTable = null; 
    13031301    if (compression == JPEG) { 
     
    14191417          byte[] bytes = new byte[(int) stripByteCounts[strip]]; 
    14201418          in.read(bytes); 
    1421           if (compression != PACK_BITS) { 
    1422             if (jpegTable != null) { 
    1423               byte[] q = new byte[jpegTable.length + bytes.length - 4]; 
    1424               System.arraycopy(jpegTable, 0, q, 0, jpegTable.length - 2); 
    1425               System.arraycopy(bytes, 2, q, jpegTable.length - 2, 
    1426                 bytes.length - 2); 
    1427               bytes = uncompress(q, compression, size); 
     1419          if (jpegTable != null) { 
     1420            byte[] q = new byte[jpegTable.length + bytes.length - 4]; 
     1421            System.arraycopy(jpegTable, 0, q, 0, jpegTable.length - 2); 
     1422            System.arraycopy(bytes, 2, q, jpegTable.length - 2, 
     1423              bytes.length - 2); 
     1424            bytes = uncompress(q, compression, size); 
     1425          } 
     1426          else bytes = uncompress(bytes, compression, size); 
     1427 
     1428          undifference(bytes, bitsPerSample, 
     1429            imageWidth, planarConfig, predictor, littleEndian); 
     1430 
     1431          if (x != 0 || width != imageWidth || y != 0 || 
     1432            height != imageLength) 
     1433          { 
     1434            byte[] tmp = bytes; 
     1435            int extra = (int) bitsPerSample[0] / 8; 
     1436            if (planarConfig != 2) extra *= samplesPerPixel; 
     1437            int rowLen = (int) width * extra; 
     1438            int srcRowLen = (int) imageWidth * extra; 
     1439            bytes = new byte[(int) (nRows * extra * width)]; 
     1440 
     1441            int startRow = (row % imageLength) < y ? 
     1442              (int) (y - (row % imageLength)) : 0; 
     1443            int endRow = (int) ((row % imageLength) + rowsPerStrip > 
     1444              y + height ?  y + height - (row % imageLength) : rowsPerStrip); 
     1445            for (int n=startRow; n<endRow; n++) { 
     1446              int srcOffset = n * srcRowLen + x * extra; 
     1447              System.arraycopy(tmp, srcOffset, bytes, 
     1448                (n - startRow) * rowLen, rowLen); 
    14281449            } 
    1429             else bytes = uncompress(bytes, compression, size); 
    1430  
    1431             undifference(bytes, bitsPerSample, 
    1432               imageWidth, planarConfig, predictor, littleEndian); 
    1433  
    1434             if (x != 0 || width != imageWidth || y != 0 || 
    1435               height != imageLength) 
    1436             { 
    1437               byte[] tmp = bytes; 
    1438               int extra = (int) bitsPerSample[0] / 8; 
    1439               if (planarConfig != 2) extra *= samplesPerPixel; 
    1440               int rowLen = (int) width * extra; 
    1441               int srcRowLen = (int) imageWidth * extra; 
    1442               bytes = new byte[(int) (nRows * extra * width)]; 
    1443  
    1444               int startRow = (row % imageLength) < y ? 
    1445                 (int) (y - (row % imageLength)) : 0; 
    1446               int endRow = (int) ((row % imageLength) + rowsPerStrip > 
    1447                 y + height ?  y + height - (row % imageLength) : rowsPerStrip); 
    1448               for (int n=startRow; n<endRow; n++) { 
    1449                 int srcOffset = n * srcRowLen + x * extra; 
    1450                 System.arraycopy(tmp, srcOffset, bytes, 
    1451                   (n - startRow) * rowLen, rowLen); 
    1452               } 
    1453               nRows = endRow - startRow; 
    1454             } 
    1455  
    1456             unpackBytes(buf, offset, bytes, bitsPerSample, 
    1457               photoInterp, colorMap, littleEndian, maxValue, planarConfig, 
    1458               strip, (int) numStrips, width); 
    1459             int div = bitsPerSample[0] / 8; 
    1460             if (div == 0) div = 1; 
    1461             if (bitsPerSample[0] % 8 != 0) div++; 
    1462             if (planarConfig != 2) div *= samplesPerPixel; 
    1463             offset += bytes.length / div; 
    1464           } 
    1465           else { 
    1466             // concatenate contents of bytes to altBytes 
    1467             byte[] tempPackBits = new byte[altBytes.length]; 
    1468             System.arraycopy(altBytes, 0, tempPackBits, 0, altBytes.length); 
    1469             altBytes = new byte[altBytes.length + bytes.length]; 
    1470             System.arraycopy(tempPackBits, 0, altBytes, 0, tempPackBits.length); 
    1471             System.arraycopy(bytes, 0, altBytes, 
    1472               tempPackBits.length, bytes.length); 
    1473           } 
     1450            nRows = endRow - startRow; 
     1451          } 
     1452 
     1453          unpackBytes(buf, offset, bytes, bitsPerSample, 
     1454            photoInterp, colorMap, littleEndian, maxValue, planarConfig, 
     1455            strip, (int) numStrips, width); 
     1456          int div = bitsPerSample[0] / 8; 
     1457          if (div == 0) div = 1; 
     1458          if (bitsPerSample[0] % 8 != 0) div++; 
     1459          if (planarConfig != 2) div *= samplesPerPixel; 
     1460          offset += bytes.length / div; 
    14741461        } 
    14751462        catch (Exception e) { 
     
    14871474            strip, (int) numStrips, imageWidth); 
    14881475        } 
    1489       } 
    1490     } 
    1491  
    1492     // only do this if the image uses PackBits compression 
    1493     if (altBytes.length != 0) { 
    1494       int bpp = bitsPerSample[0]; 
    1495       while ((bpp % 8) != 0) bpp++; 
    1496       bpp /= 8; 
    1497  
    1498       altBytes = uncompress(altBytes, compression, 
    1499         (int) (imageWidth * imageLength * samplesPerPixel)); 
    1500       undifference(altBytes, bitsPerSample, 
    1501         imageWidth, planarConfig, predictor, littleEndian); 
    1502       if (width < imageWidth || height < imageLength) { 
    1503         byte[] tmp = new byte[(int) 
    1504           (imageWidth * imageLength * bitsPerSample.length * bpp)]; 
    1505         unpackBytes(tmp, 0, altBytes, bitsPerSample, 
    1506           photoInterp, colorMap, littleEndian, maxValue, planarConfig, 0, 1, 
    1507           imageWidth); 
    1508  
    1509         for (int c=0; c<bitsPerSample.length; c++) { 
    1510           for (int row=y; row<y+height; row++) { 
    1511             System.arraycopy(tmp, (int) (c*imageWidth*imageLength*bpp + 
    1512               row*imageWidth*bpp) + x*bpp, buf, (int) (c*width*height*bpp + 
    1513               (row - y)*width*bpp), (int) (bpp*width)); 
    1514           } 
    1515         } 
    1516       } 
    1517       else { 
    1518         unpackBytes(buf, 0, altBytes, bitsPerSample, 
    1519           photoInterp, colorMap, littleEndian, maxValue, planarConfig, 0, 1, 
    1520           imageWidth); 
    15211476      } 
    15221477    } 
Note: See TracChangeset for help on using the changeset viewer.