/** * Reads an array of strings from the TIFF file. * * @param count Number of strings to read * @param value Offset from which to read */ protected String[] readASCIIArray(long count, long value) throws IOException { _raf.seek(value); int nstrs = 0; List list = new LinkedList(); byte[] buf = new byte[(int) count]; _raf.read(buf); StringBuffer strbuf = new StringBuffer(); for (int i = 0; i < count; i++) { int b = buf[i]; if (b == 0) { list.add(strbuf.toString()); strbuf.setLength(0); } else { strbuf.append((char) b); } } /* We can't use ArrayList.toArray because that returns an Object[], not a String[] ... sigh. */ String[] strs = new String[nstrs]; ListIterator iter = list.listIterator(); for (int i = 0; i < nstrs; i++) { strs[i] = (String) iter.next(); } return strs; }
public static void writeArray(String s, int[] x) { try { RandomAccessFile output = new RandomAccessFile(s, "rw"); for (int i = 0; i < x.length; i++) output.writeInt(x[i]); } catch (IOException e) { System.out.println(e.getMessage()); } }
/** * Record a specific string * * @param s */ public static void record(String s) { try { if (!recording) return; Date now = new Date(); String ts = stamp.format(now); R.writeBytes(ts); R.writeBytes(" "); R.writeBytes(s); R.writeBytes("\n"); } catch (Exception e) { e.printStackTrace(); } }
/** * Reads a string value from the TIFF file. * * @param count Length of string * @param value Offset of string */ protected String readASCII(long count, long value) throws IOException { _raf.seek(value); byte[] buffer = new byte[(int) count]; _raf.read(buffer); StringBuffer sb = new StringBuffer(); for (int i = 0; i < count; i++) { if (buffer[i] == 0) { break; } sb.append((char) buffer[i]); } return sb.toString(); }
/** Reads an array of SRATIONAL values and returns it as an array of Rational. */ protected Rational[] readSignedRationalArray(long count, long value) throws IOException { _raf.seek(value); byte[] buffer = new byte[(int) calcValueSize(SRATIONAL, count)]; _raf.read(buffer); DataInputStream stream = new DataInputStream(new ByteArrayInputStream(buffer)); Rational[] rarray = new Rational[(int) count]; for (int i = 0; i < count; i++) { long numer = ModuleBase.readSignedInt(stream, _bigEndian, null); long denom = ModuleBase.readSignedInt(stream, _bigEndian, null); rarray[i] = new Rational(numer, denom); } return rarray; }
/** Reads an SRATIONAL value and returns it as a Rational. */ protected Rational readSignedRational(long count, long value) throws IOException { _raf.seek(value); long numer = ModuleBase.readSignedInt(_raf, _bigEndian); long denom = ModuleBase.readSignedInt(_raf, _bigEndian); return new Rational(numer, denom); }
/** * Start recording * * @param stub */ public static void startRecorder(String stub) { try { stamp = new SimpleDateFormat("HH:mm:ss"); SimpleDateFormat dateformat = new SimpleDateFormat("yyMMdd"); Date d = new Date(); String s = dateformat.format(d); String name = logdir + stub + s + ".txt"; R = new RandomAccessFile(name, "rw"); System.out.println("Log file: " + name); long N = R.length(); R.seek(N); recording = true; } catch (Exception e) { e.printStackTrace(); } }
/** * Read block from file. * * @param file - File to read. * @param off - Marker position in file to start read from if {@code -1} read last blockSz bytes. * @param blockSz - Maximum number of chars to read. * @param lastModified - File last modification time. * @return Read file block. * @throws IOException In case of error. */ public static VisorFileBlock readBlock(File file, long off, int blockSz, long lastModified) throws IOException { RandomAccessFile raf = null; try { long fSz = file.length(); long fLastModified = file.lastModified(); long pos = off >= 0 ? off : Math.max(fSz - blockSz, 0); // Try read more that file length. if (fLastModified == lastModified && fSz != 0 && pos >= fSz) throw new IOException( "Trying to read file block with wrong offset: " + pos + " while file size: " + fSz); if (fSz == 0) return new VisorFileBlock(file.getPath(), pos, fLastModified, 0, false, EMPTY_FILE_BUF); else { int toRead = Math.min(blockSz, (int) (fSz - pos)); byte[] buf = new byte[toRead]; raf = new RandomAccessFile(file, "r"); raf.seek(pos); int cntRead = raf.read(buf, 0, toRead); if (cntRead != toRead) throw new IOException( "Count of requested and actually read bytes does not match [cntRead=" + cntRead + ", toRead=" + toRead + ']'); boolean zipped = buf.length > 512; return new VisorFileBlock( file.getPath(), pos, fSz, fLastModified, zipped, zipped ? zipBytes(buf) : buf); } } finally { U.close(raf, null); } }
/** Reads a TIFF array of signed 16-bit values and returns it as an int array. */ protected int[] readSShortArray(int type, long count, long value) throws IOException { _raf.seek(value); int[] iarray = new int[(int) count]; for (int i = 0; i < count; i++) { iarray[i] = ModuleBase.readSignedShort(_raf, _bigEndian); } return iarray; }
/** * Reads a TIFF array of signed 32-bit integer values and returns it as a long array. * * @param type TIFF type to read; must be a 32-bit type * @param count Number of values to read * @param value Offset from which to read */ protected long[] readLongArray(int type, long count, long value) throws IOException { _raf.seek(value); long[] array = new long[(int) count]; for (int i = 0; i < count; i++) { array[i] = readUnsigned(type); } return array; }
/** Reads a TIFF array of unsigned 16-bit values and returns it as an int array. */ protected int[] readShortArray(int type, long count, long value) throws IOException { _raf.seek(value); int[] iarray = new int[(int) count]; for (int i = 0; i < count; i++) { iarray[i] = (int) readUnsigned(type); } return iarray; }
/** * Stop recording. This is not strictly necessary since the RandomAccessFile will keep most of the * information that has been logged. */ public static void endRecord() { try { if (!recording) return; if (R != null) R.close(); if (recording) recording = false; } catch (Exception e) { e.printStackTrace(); } }
/** * Reads a TIFF array of DOUBLE 64-bit values and returns it as a double array. * * @param count Number of values to read * @param value Offset from which to read */ protected double[] readDoubleArray(long count, long value) throws IOException { _raf.seek(value); double[] darray = new double[(int) count]; for (int i = 0; i < count; i++) { darray[i] = ModuleBase.readDouble(_raf, _bigEndian); } return darray; }
public static String readArray(String s) { String output = "[ "; boolean endOfFile = false; try { RandomAccessFile input = new RandomAccessFile(s, "rw"); input.seek(0); while (!endOfFile) { try { output = output + input.readInt() + " "; } catch (EOFException e) { endOfFile = true; output = output + "]"; } } } catch (IOException e) { return e.getMessage(); } return output; }
/** * Decode file charset. * * @param f File to process. * @return File charset. * @throws IOException in case of error. */ public static Charset decode(File f) throws IOException { SortedMap<String, Charset> charsets = Charset.availableCharsets(); String[] firstCharsets = { Charset.defaultCharset().name(), "US-ASCII", "UTF-8", "UTF-16BE", "UTF-16LE" }; Collection<Charset> orderedCharsets = U.newLinkedHashSet(charsets.size()); for (String c : firstCharsets) if (charsets.containsKey(c)) orderedCharsets.add(charsets.get(c)); orderedCharsets.addAll(charsets.values()); try (RandomAccessFile raf = new RandomAccessFile(f, "r")) { FileChannel ch = raf.getChannel(); ByteBuffer buf = ByteBuffer.allocate(4096); ch.read(buf); buf.flip(); for (Charset charset : orderedCharsets) { CharsetDecoder decoder = charset.newDecoder(); decoder.reset(); try { decoder.decode(buf); return charset; } catch (CharacterCodingException ignored) { } } } return Charset.defaultCharset(); }
/** * Reads and returns a single unsigned 32-bit integer value. * * @param type TIFF type to read; must be a 32-bit type * @param count Unused * @param value Offset from which to read */ protected long readLong(int type, long count, long value) throws IOException { _raf.seek(value); return readUnsigned(type); }
/** * Reads an array of bytes and returns it as a byte array. * * @param type Unused * @param count Number of bytes to read * @param value Offset from which to read */ protected byte[] readTrueByteArray(int type, long count, long value) throws IOException { _raf.seek(value); byte[] array = new byte[(int) count]; _raf.read(array); return array; }
/** * Parse the IFD. Errors are not suppressed. * * @param byteOffsetIsValid If true, allow offsets on odd byte boundaries * @return The offset of the next IFD */ public long parse(boolean byteOffsetIsValid) throws TiffException { /* Start at the IFD offset, read the number of entries, then * read the entire IFD. */ long offset = _offset; _next = 0L; byte[] buffer; int nFields = 0; try { _raf.seek(offset); nFields = ModuleBase.readUnsignedShort(_raf, _bigEndian); offset += 2; int len = 12 * nFields; buffer = new byte[len]; _raf.read(buffer, 0, len); /* Read the offset of the next IFD (or 0 if none). */ offset += len; _next = ModuleBase.readUnsignedInt(_raf, _bigEndian); } catch (Exception e) { throw new TiffException("Premature EOF", offset); } DataInputStream ifdStream = new DataInputStream(new ByteArrayInputStream(buffer)); try { int prevTag = 0; for (int i = 0; i < nFields; i++) { int tag = ModuleBase.readUnsignedShort(ifdStream, _bigEndian, null); /* Tags must be in ascending numerical order. */ if (!debug_allowoutofsequence && tag < prevTag) { _info.setMessage( new ErrorMessage("Tag " + tag + " out of sequence", _offset + 2 + 12 * i)); _info.setWellFormed(false); } prevTag = tag; int type = ModuleBase.readUnsignedShort(ifdStream, _bigEndian, null); /* Skip over tags with unknown type. */ if (type < BYTE || type > IFD) { _info.setMessage( new ErrorMessage( "Unknown data type", "Type = " + type + ", Tag = " + tag, _offset + 4 + 12 * i)); } else { /* Type gives indication of the TIFF version. */ if (SBYTE <= type && type <= IFD) { _version = 6; } long count = ModuleBase.readUnsignedInt(ifdStream, _bigEndian, null); long value = ModuleBase.readUnsignedInt(ifdStream, _bigEndian, null); if (calcValueSize(type, count) > 4) { /* Value is the word-aligned offset of the actual * value. */ if ((value & 1) != 0) { if (byteOffsetIsValid) { _info.setMessage( new InfoMessage( "Value offset not word-aligned: " + value, _offset + 10 + 12 * i)); } else { throw new TiffException( "Value offset not " + "word-aligned: " + value, _offset + 10 + 12 * i); } } } else { /* Value is the actual value; pass the offset of * the value. */ value = _offset + 10 + 12 * i; } lookupTag(tag, type, count, value); } } } catch (IOException e) { throw new TiffException("Read error", _offset + 2); } postParseInitialization(); return _next; }
/** Reads and returns a single unsigned 16-bit value. */ protected int readShort(int type, long count, long value) throws IOException { _raf.seek(value); return (int) readUnsigned(type); }