Kann eine TIFF-Datei nicht richtig kodieren, einige Zeichen codieren nicht

Question

Ich habe TIFF-Datei, die mehrere Bilder enthält, muss ich durch diese TIFF-Datei, um die Bilder separat zu extrahieren, Ich habe Base64-Codierung verwendet, dann Teilzeichenfolge verwendet um die Bilder zu trennen und Base64 zu benutzen, um in ein Dateisystem zu schreiben, Jedoch können nur einige Bilder extrahiert werden.

Beispiel: Ich habe 7 Bilder in einer TIFF-Datei, aber es extrahiert nur 4 Bilder.

Also habe ich die codierten Daten in eine Datei schreiben und lesen, und ich kann nur das II * codieren Zeichen als 4 Stellen statt 7 sehen. Wenn ich die TIFF-Datei mit namedpad öffnen, kann ich sehen 7 II *. Bitte beraten Sie, die beste Methode, dies zu tun.

Ich habe versucht, die ecoded Datei zu dekodieren und es ist korrekt, es hat 7 II *, aber in der ecoded Datei kann ich nur die 4 codierten (SUkq) Wert von II * sehen.

Ich kann den folgenden Code nicht verwenden, da meine TIFF-Datei einen Header-Teil vor dem II * enthält, der entfernt werden muss, bevor ich die folgende Methode verwende.

Klasse

public void doitJAI() throws IOException { 
    FileSeekableStream ss = new FileSeekableStream("D:\\Users\\Vinoth\\workspace\\image.tif"); 
    ImageDecoder dec = ImageCodec.createImageDecoder("tiff", ss, null); 
    int count = dec.getNumPages(); 
    TIFFEncodeParam param = new TIFFEncodeParam(); 
    param.setCompression(TIFFEncodeParam.COMPRESSION_GROUP4); 
    param.setLittleEndian(false); // Intel 
    System.out.println("This TIF has " + count + " image(s)"); 
    for (int i = 0; i < count; i++) { 
     RenderedImage page = dec.decodeAsRenderedImage(i); 
     File f = new File("D:\\Users\\Vinoth\\workspace\\single_" + i + ".tif"); 
     System.out.println("Saving " + f.getCanonicalPath()); 
     ParameterBlock pb = new ParameterBlock(); 
     pb.addSource(page); 
     pb.add(f.toString()); 
     pb.add("tiff"); 
     pb.add(param); 
     RenderedOp r = JAI.create("filestore",pb); 
     r.dispose(); 
    } 
} 

so Im den folgenden Code verwenden, ist dies nur das erste Bild zu extrahieren.

Klasse

public class SplitTIFFFile { 

public static void main(String[] args) throws IOException { 
    new SplitTIFFFile().doitJAI(); 
} 

File file = new File("D:\\Users\\Vinoth\\workspace\\Testing\\image.tif"); 

    try { 

       FileOutputStream imageOutFile; 
       /*imageOutFile*/ try (/* 
       * Reading a Image file from file system 
       */ FileInputStream imageInFile = new FileInputStream(file)) { 
        byte imageData[] = new byte[(int)file.length()]; 
        imageInFile.read(imageData); 
        /* 
        * Converting Image byte array into Base64 String 
        */ 
        String imageDataString = encodeImage(imageData); 
        String result = imageDataString.substring(imageDataString.indexOf("SUkq") , imageDataString.indexOf("SUkq")); 
        /* 
        * Converting a Base64 String into Image byte array 
        */ 
        byte[] imageByteArray = decodeImage(result); 

        /* 
        * Write a image byte array into file system 
        */ 
        imageOutFile = new FileOutputStream("D:\\Users\\Vinoth\\workspace\\Testing\\image_converted_Vinoth_2.jpg"); 
        imageOutFile.write(imageByteArray); 
       } 
     imageOutFile.close(); 

     System.out.println("Image Successfully Manipulated!"); 
    } 

      catch (FileNotFoundException e) { 
     System.out.println("Image not found" + e); 
    } catch (IOException ioe) { 
     System.out.println("Exception while reading the Image " + ioe); 
    } 

} 

/** 
* Encodes the byte array into base64 string 
* @param imageByteArray - byte array 
* @return String a {@link java.lang.String} 
*/ 
public static String encodeImage(byte[] imageByteArray){   
    return Base64.encodeBase64URLSafeString(imageByteArray);   
} 

/** 
* Decodes the base64 string into byte array 
* @param imageDataString - a {@link java.lang.String} 
* @return byte array 
*/ 
public static byte[] decodeImage(String imageDataString) {  
    return Base64.decodeBase64(imageDataString); 
} 

} 
} 

Answer 1

einfach keine Umwandlung von byte[] zu einem Base64 String verwenden und dann "SUkq" suchen.

SUkq repräsentieren 3 Bytes (ASCII II* = byte[] { 73, 73, 42 }), aber wenn diese 3 Bytes um 1 oder 2 Positionen verschoben werden, passiert eine völlig andere Zeichenfolge, die 5 Buchstaben benötigt.

Der Code mit Byte nur:

byte[] imageData = Files.readAllBytes(file.toPath()); 

    final byte[] soughtBytes = { 73, 73, 42 }; 
    int from = indexOf(imageData, soughtBytes, 0); 
    from += soughtBytes.length; 
    int to = indexOf(imageData, soughtBytes, from); 
    if (to == -1) { 
     throw new IllegalArgumentException(); 
    } 
    byte[] imageByteArray = Arrays.copyOfRange(imageData, from, to); 

    Path imageOutFile = Paths.get(
       "D:\\Users\\Vinoth\\workspace\\Testing\\image_converted_Vinoth_2.jpg"); 
    Files.write(imageOutFile, imageByteArray); 
} 

static int indexOf(byte[] totalBytes, byte[] soughtBytes, int start) { 
    for (int index = start; index <= totalBytes.length - soughtBytes.length; ++index) { 
     boolean equal = true; 
     for (int i = 0; i < soughtBytes.length; ++i) { 
      if (totalBytes[index + i] != soughtBytes[i]) { 
       equal = false; 
       break; 
      } 
     } 
     if (equal) { 
      return index; 
     } 
    } 
    return -1; 
} 

Das die Bytes speichert zwischen der ersten beiden "II *".

Nicht getestet.