Java Code Examples for java.io.BufferedInputStream#mark()

static byte[] getProfileDataFromStream(InputStream s) throws IOException {

        BufferedInputStream bis = new BufferedInputStream(s);
        bis.mark(128);

        byte[] header = IOUtils.readNBytes(bis, 128);
        if (header[36] != 0x61 || header[37] != 0x63 ||
            header[38] != 0x73 || header[39] != 0x70) {
            return null;   /* not a valid profile */
        }
        int profileSize = ((header[0] & 0xff) << 24) |
                          ((header[1] & 0xff) << 16) |
                          ((header[2] & 0xff) << 8) |
                          (header[3] & 0xff);
        bis.reset();
        try {
            return IOUtils.readNBytes(bis, profileSize);
        } catch (OutOfMemoryError e) {
            throw new IOException("Color profile is too big");
        }
    }
 

private void testNegative(final int readLimit) throws IOException {
    byte[] bytes = new byte[100];
    for (int i=0; i < bytes.length; i++)
        bytes[i] = (byte)i;
    // buffer of 10 bytes
    BufferedInputStream bis =
        new BufferedInputStream(new ByteArrayInputStream(bytes), 10);
    // skip 10 bytes
    bis.skip(10);
    bis.mark(readLimit);   // 1 byte short in buffer size
    // read 30 bytes in total, with internal buffer incread to 20
    bis.read(new byte[20]);
    try {
        bis.reset();
        fail();
    } catch(IOException ex) {
        assertEquals("Resetting to invalid mark", ex.getMessage());
    }
}
 

public static Bitmap decodeSampledBitmapFromStream(InputStream inputStream,
                                                     int reqWidth, int reqHeight) {
    final BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
    bufferedInputStream.mark(Integer.MAX_VALUE);

    // First decode with inJustDecodeBounds = true to check dimensions
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeStream(bufferedInputStream, null, options);

    // Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

    try {
        bufferedInputStream.reset();
    } catch (IOException e) {
        Timber.w("Could not reposition the stream:" + e);
    }

    // Decode bitmap with inSampleSize set
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeStream(bufferedInputStream, null, options);
}
 

/**
 * Wraps an xml input xstream in a buffered reader specifying a lookahead that can be used to
 * preparse some of the xml document, resetting it back to its original state for actual
 * parsing.
 *
 * @param stream The original xml stream.
 * @param xmlLookahead The number of bytes to support for parse. If more than this number of
 *     bytes are preparsed the stream can not be properly reset.
 * @return The buffered reader.
 */
public static BufferedReader getBufferedXMLReader(InputStream stream, int xmlLookahead)
        throws IOException {

    // create a buffer so we can reset the input stream
    BufferedInputStream input = new BufferedInputStream(stream);
    input.mark(xmlLookahead);

    // create object to hold encoding info
    EncodingInfo encoding = new EncodingInfo();

    // call this method to set the encoding info
    XmlCharsetDetector.getCharsetAwareReader(input, encoding);

    // call this method to create the reader
    Reader reader = XmlCharsetDetector.createReader(input, encoding);

    // rest the input
    input.reset();

    return getBufferedXMLReader(reader, xmlLookahead);
}
 

private void testPositive(final int readLimit) throws IOException {
    byte[] bytes = new byte[100];
    for (int i = 0; i < bytes.length; i++) {
        bytes[i] = (byte) i;
    }
    // buffer of 10 bytes
    BufferedInputStream bis =
            new BufferedInputStream(new ByteArrayInputStream(bytes), 10);
    // skip 10 bytes
    bis.skip(10);
    bis.mark(readLimit);   // buffer size would increase up to readLimit
    // read 30 bytes in total, with internal buffer increased to 20
    bis.read(new byte[20]);
    bis.reset();
    assert (bis.read() == 10);
}
 

public JavaSoundAudioClip(InputStream in) throws IOException {
    if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip.<init>");

    BufferedInputStream bis = new BufferedInputStream(in, STREAM_BUFFER_SIZE);
    bis.mark(STREAM_BUFFER_SIZE);
    boolean success = false;
    try {
        AudioInputStream as = AudioSystem.getAudioInputStream(bis);
        // load the stream data into memory
        success = loadAudioData(as);

        if (success) {
            success = false;
            if (loadedAudioByteLength < CLIP_THRESHOLD) {
                success = createClip();
            }
            if (!success) {
                success = createSourceDataLine();
            }
        }
    } catch (UnsupportedAudioFileException e) {
        // not an audio file
        try {
            MidiFileFormat mff = MidiSystem.getMidiFileFormat(bis);
            success = createSequencer(bis);
        } catch (InvalidMidiDataException e1) {
            success = false;
        }
    }
    if (!success) {
        throw new IOException("Unable to create AudioClip from input stream");
    }
}
 

private Bitmap getSampleBitmap(InputStream is, int width, int height) {

        BufferedInputStream stream = new BufferedInputStream(is);
        stream.mark(4 * 1024);
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(stream, null, options);
        calculateInSampleSize(width, height, options, true);
        try {
            stream.reset();
        } catch (IOException e) {
        }
        return BitmapFactory.decodeStream(stream, null, options);
    }
 

protected static byte[] readBlock(int expectedTag, BufferedInputStream instream, String name)
    throws IOException {
  instream.mark(10);
  int tag = instream.read();
  assertTag(expectedTag, tag, name);

  return readBlock(instream, name);
}
 

private InputStream buildInputStream(ResponseBody responseBody) throws IOException {
    InputStream inputStream = responseBody.byteStream();

    if (includeRawResponse) {
        // we have to buffer the entire input payload, so that after processing
        // it can be re-read and used to populate the rawResponse field.

        BufferedSource source = responseBody.source();
        source.request(Long.MAX_VALUE); // Buffer the entire body
        Buffer buffer = source.buffer();

        long size = buffer.size();
        if (size > Integer.MAX_VALUE) {
            throw new UnsupportedOperationException(
                    "Non-integer input buffer size specified: " + size);
        }

        int bufferSize = (int) size;
        BufferedInputStream bufferedinputStream =
                new BufferedInputStream(inputStream, bufferSize);

        bufferedinputStream.mark(inputStream.available());
        return bufferedinputStream;

    } else {
        return inputStream;
    }
}
 

/**
 * Returns true if we are confident that we can read data from this
 * connection. This is more expensive and more accurate than {@link
 * #isAlive()}; callers should check {@link #isAlive()} first.
 */
public boolean isReadable() {
  if (!(in instanceof BufferedInputStream)) {
    return true; // Optimistic.
  }
  if (isSpdy()) {
    return true; // Optimistic. We can't test SPDY because its streams are in use.
  }
  BufferedInputStream bufferedInputStream = (BufferedInputStream) in;
  try {
    int readTimeout = socket.getSoTimeout();
    try {
      socket.setSoTimeout(1);
      bufferedInputStream.mark(1);
      if (bufferedInputStream.read() == -1) {
        return false; // Stream is exhausted; socket is closed.
      }
      bufferedInputStream.reset();
      return true;
    } finally {
      socket.setSoTimeout(readTimeout);
    }
  } catch (SocketTimeoutException ignored) {
    return true; // Read timed out; socket is good.
  } catch (IOException e) {
    return false; // Couldn't read; socket is closed.
  }
}
 

private static boolean peekStream( BufferedInputStream in ) 
    throws IOException {
    
    in.mark( 1 );
    boolean notYet =  in.read() > -1;
    in.reset();
    return notYet;
    
}
 

/**
 * @see org.newdawn.slick.opengl.LoadableImageData#loadImage(java.io.InputStream, boolean, boolean, int[])
 */
public ByteBuffer loadImage(InputStream is, boolean flipped, boolean forceAlpha, int[] transparent) throws IOException {
	CompositeIOException exception = new CompositeIOException();
	ByteBuffer buffer = null;
	
	BufferedInputStream in = new BufferedInputStream(is, is.available());
	in.mark(is.available());
	
	// cycle through our source until one of them works
	for (int i=0;i<sources.size();i++) {
		in.reset();
		try {
			LoadableImageData data = (LoadableImageData) sources.get(i);
			
			buffer = data.loadImage(in, flipped, forceAlpha, transparent);
			picked = data;
			break;
		} catch (Exception e) {
			Log.warn(sources.get(i).getClass()+" failed to read the data", e);
			exception.addException(e);
		}
	}
	
	if (picked == null) {
		throw exception;
	}
	
	return buffer;
}
 

public JavaSoundAudioClip(InputStream in) throws IOException {
    if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip.<init>");

    BufferedInputStream bis = new BufferedInputStream(in, STREAM_BUFFER_SIZE);
    bis.mark(STREAM_BUFFER_SIZE);
    boolean success = false;
    try {
        AudioInputStream as = AudioSystem.getAudioInputStream(bis);
        // load the stream data into memory
        success = loadAudioData(as);

        if (success) {
            success = false;
            if (loadedAudioByteLength < CLIP_THRESHOLD) {
                success = createClip();
            }
            if (!success) {
                success = createSourceDataLine();
            }
        }
    } catch (UnsupportedAudioFileException e) {
        // not an audio file
        try {
            MidiFileFormat mff = MidiSystem.getMidiFileFormat(bis);
            success = createSequencer(bis);
        } catch (InvalidMidiDataException e1) {
            success = false;
        }
    }
    if (!success) {
        throw new IOException("Unable to create AudioClip from input stream");
    }
}
 

/**
 * {@inheritDoc}
 */
@Override public ProjectFile read(InputStream inputStream) throws MPXJException
{
   try
   {
      BufferedInputStream is = new BufferedInputStream(inputStream);
      is.mark(100);
      byte[] buffer = new byte[SQLITE_TEXT.length()];
      is.read(buffer);
      is.reset();
      String actualText = new String(buffer);
      ProjectFile result;
      if (SQLITE_TEXT.equals(actualText))
      {
         result = readDatabaseFile(is);
      }
      else
      {
         result = readTextFile(is);
      }
      return result;
   }

   catch (IOException ex)
   {
      throw new MPXJException("Failed to read file", ex);
   }
}
 

public JavaSoundAudioClip(InputStream in) throws IOException {
    if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip.<init>");

    BufferedInputStream bis = new BufferedInputStream(in, STREAM_BUFFER_SIZE);
    bis.mark(STREAM_BUFFER_SIZE);
    boolean success = false;
    try {
        AudioInputStream as = AudioSystem.getAudioInputStream(bis);
        // load the stream data into memory
        success = loadAudioData(as);

        if (success) {
            success = false;
            if (loadedAudioByteLength < CLIP_THRESHOLD) {
                success = createClip();
            }
            if (!success) {
                success = createSourceDataLine();
            }
        }
    } catch (UnsupportedAudioFileException e) {
        // not an audio file
        try {
            MidiFileFormat mff = MidiSystem.getMidiFileFormat(bis);
            success = createSequencer(bis);
        } catch (InvalidMidiDataException e1) {
            success = false;
        }
    }
    if (!success) {
        throw new IOException("Unable to create AudioClip from input stream");
    }
}
 

static byte[] readMagic(BufferedInputStream in) throws IOException {
    in.mark(4);
    byte[] magic = new byte[4];
    for (int i = 0; i < magic.length; i++) {
        // read 1 byte at a time, so we always get 4
        if (1 != in.read(magic, i, 1))
            break;
    }
    in.reset();
    return magic;
}
 

/**
 * Returns true if we are confident that we can read data from this
 * connection. This is more expensive and more accurate than {@link
 * #isAlive()}; callers should check {@link #isAlive()} first.
 */
public boolean isReadable() {
  if (!(in instanceof BufferedInputStream)) {
    return true; // Optimistic.
  }
  if (isSpdy()) {
    return true; // Optimistic. We can't test SPDY because its streams are in use.
  }
  BufferedInputStream bufferedInputStream = (BufferedInputStream) in;
  try {
    int readTimeout = socket.getSoTimeout();
    try {
      socket.setSoTimeout(1);
      bufferedInputStream.mark(1);
      if (bufferedInputStream.read() == -1) {
        return false; // Stream is exhausted; socket is closed.
      }
      bufferedInputStream.reset();
      return true;
    } finally {
      socket.setSoTimeout(readTimeout);
    }
  } catch (SocketTimeoutException ignored) {
    return true; // Read timed out; socket is good.
  } catch (IOException e) {
    return false; // Couldn't read; socket is closed.
  }
}
 

private InputStream buildInputStream(ResponseBody responseBody) throws IOException {
    InputStream inputStream = responseBody.byteStream();

    if (includeRawResponse) {
        // we have to buffer the entire input payload, so that after processing
        // it can be re-read and used to populate the rawResponse field.

        BufferedSource source = responseBody.source();
        source.request(Long.MAX_VALUE); // Buffer the entire body
        Buffer buffer = source.buffer();

        long size = buffer.size();
        if (size > Integer.MAX_VALUE) {
            throw new UnsupportedOperationException(
                    "Non-integer input buffer size specified: " + size);
        }

        int bufferSize = (int) size;
        BufferedInputStream bufferedinputStream =
                new BufferedInputStream(inputStream, bufferSize);

        bufferedinputStream.mark(inputStream.available());
        return bufferedinputStream;

    } else {
        return inputStream;
    }
}
 

public static String getEncoding(File file) {
	String charset = "GBK";
	byte[] first3Bytes = new byte[3];
	boolean checked = false;
	try {
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
		bis.mark(0);
		int read = bis.read(first3Bytes, 0, 3);
		if (read == -1)
			return charset;
		if (first3Bytes[0] == (byte) 0xFF && first3Bytes[1] == (byte) 0xFE) {
			charset = "UTF-16LE";
			checked = true;
		}
		else if (first3Bytes[0] == (byte) 0xFE
				&& first3Bytes[1] == (byte) 0xFF) {
			charset = "UTF-16BE";
			checked = true;
		}
		else if (first3Bytes[0] == (byte) 0xEF
				&& first3Bytes[1] == (byte) 0xBB
				&& first3Bytes[2] == (byte) 0xBF) {
			charset = "UTF-8";
			checked = true;
		}
		bis.reset();
		if (!checked) {
			int loc = 0;
			while ((read = bis.read()) != -1) {
				loc++;
				if (read >= 0xF0)
					break;
				if (0x80 <= read && read <= 0xBF) // 单独出现BF以下的，也算是GBK
					break;
				if (0xC0 <= read && read <= 0xDF) {
					read = bis.read();
					if (0x80 <= read && read <= 0xBF) // 双字节 (0xC0 - 0xDF)// (0x80 - 0xBF),也可能在GB编码内
						continue;
					else
						break;
				}
				else if (0xE0 <= read && read <= 0xEF) {// 也有可能出错，但是几率较小
					read = bis.read();
					if (0x80 <= read && read <= 0xBF) {
						read = bis.read();
						if (0x80 <= read && read <= 0xBF) {
							charset = "UTF-8";
							break;
						}
						else
							break;
					}
					else
						break;
				}
			}
		}
		bis.close();
	} catch (Exception e) {
		e.printStackTrace();
	}
	return charset;
}
 

/**
 * Reads the first bytes of the given input stream and tries to
 * determine the file format. Resets the input stream to the position
 * it had when the method was called. Reads up to 100 KB and before
 * giving up. Note that you can supply an additional file name to help
 * the method to determine the exact file format. If you don't know the
 * file name you can pass null, but in this case the method's result
 * might be wrong (depending on the input stream's contents).
 * @param bis a buffered input stream that supports the mark and reset
 * methods
 * @param filename the name of the input file (can be null if you don't
 * know the name)
 * @return the file format (or {@link FileFormat#UNKNOWN} if the format
 * could not be determined)
 * @throws IOException if the input stream could not be read
 */
public FileFormat determineFileFormat(BufferedInputStream bis,
        String filename) throws IOException {
    int len = 1024 * 100;

    String ext = "";
    if (filename != null) {
        int dot = filename.lastIndexOf('.');
        if (dot > 0) {
            ext = filename.substring(dot + 1);
        }
    }

    // check the first couple of bytes
    bis.mark(len);
    try {
        byte[] firstCharacters = new byte[6];
        bis.read(firstCharacters);

        // check if the file starts with a %YAML directive
        if (firstCharacters[0] == '%' &&
                firstCharacters[1] == 'Y' &&
                firstCharacters[2] == 'A' &&
                firstCharacters[3] == 'M' &&
                firstCharacters[4] == 'L' &&
                Character.isWhitespace(firstCharacters[5])) {
            return FileFormat.YAML;
        }

        // check if the file starts with an EndNote tag, but
        // also make sure the extension is not 'bib' or 'yml'/'yaml'
        // because BibTeX comments and YAML directives look like
        // EndNote tags
        if (firstCharacters[0] == '%' &&
                Character.isWhitespace(firstCharacters[2]) &&
                !ext.equalsIgnoreCase("bib") &&
                !ext.equalsIgnoreCase("yaml") &&
                !ext.equalsIgnoreCase("yml")) {
            return FileFormat.ENDNOTE;
        }

        // check if the file starts with a RIS type tag
        if (firstCharacters[0] == 'T' && firstCharacters[1] == 'Y' &&
                Character.isWhitespace(firstCharacters[2]) &&
                Character.isWhitespace(firstCharacters[3]) &&
                firstCharacters[4] == '-') {
            return FileFormat.RIS;
        }
    } finally {
        bis.reset();
    }

    // now check if it's json, bibtex or yaml
    bis.mark(len);
    try {
        while (true) {
            int c = bis.read();
            --len;
            if (c < 0 || len < 2) {
                return FileFormat.UNKNOWN;
            }

            if (!Character.isWhitespace(c)) {
                if (c == '[') {
                    return FileFormat.JSON_ARRAY;
                } else if (c == '{') {
                    return FileFormat.JSON_OBJECT;
                }
                if (ext.equalsIgnoreCase("yaml") ||
                        ext.equalsIgnoreCase("yml")) {
                    return FileFormat.YAML;
                }
                return FileFormat.BIBTEX;
            }
        }
    } finally {
        bis.reset();
    }
}