diff --git a/CHANGES.txt b/CHANGES.txt
index 43cd31eaaf9..a8fbee97c87 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -39,6 +39,9 @@ Optimizations
     postings per unique term and is directly flushed into a single
     segment.  (Mike McCandless)
  
+ 3. LUCENE-892: Fixed extra "buffer to buffer copy" that sometimes
+    takes place when using compound files.  (Mike McCandless)
+
 Documentation
 
 Build
diff --git a/src/java/org/apache/lucene/index/CompoundFileReader.java b/src/java/org/apache/lucene/index/CompoundFileReader.java
index e79f8f4806b..0d2163dac43 100644
--- a/src/java/org/apache/lucene/index/CompoundFileReader.java
+++ b/src/java/org/apache/lucene/index/CompoundFileReader.java
@@ -237,7 +237,7 @@ class CompoundFileReader extends Directory {
               if(start + len > length)
                 throw new IOException("read past EOF");
               base.seek(fileOffset + start);
-              base.readBytes(b, offset, len);
+              base.readBytes(b, offset, len, false);
             }
         }
 
diff --git a/src/java/org/apache/lucene/store/BufferedIndexInput.java b/src/java/org/apache/lucene/store/BufferedIndexInput.java
index 20f9a284e05..7d0c274fcfd 100644
--- a/src/java/org/apache/lucene/store/BufferedIndexInput.java
+++ b/src/java/org/apache/lucene/store/BufferedIndexInput.java
@@ -84,8 +84,13 @@ public abstract class BufferedIndexInput extends IndexInput {
   }
 
   public void readBytes(byte[] b, int offset, int len) throws IOException {
+    readBytes(b, offset, len, true);
+  }
+
+  public void readBytes(byte[] b, int offset, int len, boolean useBuffer) throws IOException {
+
     if(len <= (bufferLength-bufferPosition)){
-      // the buffer contains enough data to satistfy this request
+      // the buffer contains enough data to satisfy this request
       if(len>0) // to allow b to be null if len is 0...
         System.arraycopy(buffer, bufferPosition, b, offset, len);
       bufferPosition+=len;
@@ -99,8 +104,9 @@ public abstract class BufferedIndexInput extends IndexInput {
         bufferPosition += available;
       }
       // and now, read the remaining 'len' bytes:
-      if(len<bufferSize){
-        // If the amount left to read is small enough, do it in the usual
+      if (useBuffer && len<bufferSize){
+        // If the amount left to read is small enough, and
+        // we are allowed to use our buffer, do it in the usual
         // buffered way: fill the buffer and copy from it:
         refill();
         if(bufferLength<len){
@@ -112,10 +118,13 @@ public abstract class BufferedIndexInput extends IndexInput {
           bufferPosition=len;
         }
       } else {
-        // The amount left to read is larger than the buffer - there's no
-        // performance reason not to read it all at once. Note that unlike
-        // the previous code of this function, there is no need to do a seek
-        // here, because there's no need to reread what we had in the buffer.
+        // The amount left to read is larger than the buffer
+        // or we've been asked to not use our buffer -
+        // there's no performance reason not to read it all
+        // at once. Note that unlike the previous code of
+        // this function, there is no need to do a seek
+        // here, because there's no need to reread what we
+        // had in the buffer.
         long after = bufferStart+bufferPosition+len;
         if(after > length())
           throw new IOException("read past EOF");
diff --git a/src/java/org/apache/lucene/store/IndexInput.java b/src/java/org/apache/lucene/store/IndexInput.java
index 71ce37b1038..a8aa50aa525 100644
--- a/src/java/org/apache/lucene/store/IndexInput.java
+++ b/src/java/org/apache/lucene/store/IndexInput.java
@@ -40,6 +40,25 @@ public abstract class IndexInput implements Cloneable {
   public abstract void readBytes(byte[] b, int offset, int len)
     throws IOException;
 
+  /** Reads a specified number of bytes into an array at the
+   * specified offset with control over whether the read
+   * should be buffered (callers who have their own buffer
+   * should pass in "false" for useBuffer).  Currently only
+   * {@link BufferedIndexInput} respects this parameter.
+   * @param b the array to read bytes into
+   * @param offset the offset in the array to start storing bytes
+   * @param len the number of bytes to read
+   * @param useBuffer set to false if the caller will handle
+   * buffering.
+   * @see IndexOutput#writeBytes(byte[],int)
+   */
+  public void readBytes(byte[] b, int offset, int len, boolean useBuffer)
+    throws IOException
+  {
+    // Default to ignoring useBuffer entirely
+    readBytes(b, offset, len);
+  }
+
   /** Reads four bytes and returns an int.
    * @see IndexOutput#writeInt(int)
    */