Fix muted audio when playback rate != 1.0 or 0.0

media/base/seekable_buffer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/base/seekable_buffer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/data_buffer.h"
@@ skipping 18 matching lines @@
   buffers_.clear();
   current_buffer_ = buffers_.begin();
   current_buffer_offset_ = 0;
   backward_bytes_ = 0;
   forward_bytes_ = 0;
   current_time_ = kNoTimestamp();
 }
 
 size_t SeekableBuffer::Read(uint8* data, size_t size) {
   DCHECK(data);
-  return InternalRead(data, size, true);
+  return InternalRead(data, size, true, 0);
 }
 
-size_t SeekableBuffer::Peek(uint8* data, size_t size) {
+size_t SeekableBuffer::Peek(uint8* data, size_t size, size_t forward_offset) {
   DCHECK(data);
-  return InternalRead(data, size, false);
+  return InternalRead(data, size, false, forward_offset);
 }
 
 bool SeekableBuffer::GetCurrentChunk(const uint8** data, size_t* size) const {
   BufferQueue::iterator current_buffer = current_buffer_;
   size_t current_buffer_offset = current_buffer_offset_;
   // Advance position if we are in the end of the current buffer.
   while (current_buffer != buffers_.end() &&
          current_buffer_offset >= (*current_buffer)->GetDataSize()) {
     ++current_buffer;
     current_buffer_offset = 0;
@@ skipping 51 matching lines @@
     return SeekBackward(-offset);
   return true;
 }
 
 bool SeekableBuffer::SeekForward(size_t size) {
   // Perform seeking forward only if we have enough bytes in the queue.
   if (size > forward_bytes_)
     return false;
 
   // Do a read of |size| bytes.
-  size_t taken = InternalRead(NULL, size, true);
+  size_t taken = InternalRead(NULL, size, true, 0);
   DCHECK_EQ(taken, size);
   return true;
 }
 
 bool SeekableBuffer::SeekBackward(size_t size) {
   if (size > backward_bytes_)
     return false;
   // Record the number of bytes taken.
   size_t taken = 0;
   // Loop until we taken enough bytes and rewind by the desired |size|.
@@ skipping 49 matching lines @@
       break;
     scoped_refptr<Buffer> buffer = *i;
     backward_bytes_ -= buffer->GetDataSize();
     DCHECK_GE(backward_bytes_, 0u);
 
     buffers_.erase(i);
   }
 }
 
 size_t SeekableBuffer::InternalRead(uint8* data, size_t size,
-                                    bool advance_position) {
+                                    bool advance_position,
+                                    size_t forward_offset) {
   // Counts how many bytes are actually read from the buffer queue.
   size_t taken = 0;
 
   BufferQueue::iterator current_buffer = current_buffer_;
   size_t current_buffer_offset = current_buffer_offset_;
 
+  size_t bytes_to_skip = forward_offset;
   while (taken < size) {
     // |current_buffer| is valid since the first time this buffer is appended
     // with data.
     if (current_buffer == buffers_.end())
       break;
 
     scoped_refptr<Buffer> buffer = *current_buffer;
 
-    // Find the right amount to copy from the current buffer referenced by
-    // |buffer|. We shall copy no more than |size| bytes in total and each
-    // single step copied no more than the current buffer size.
-    size_t copied = std::min(size - taken,
-                             buffer->GetDataSize() - current_buffer_offset);
+    size_t remaining_bytes_in_buffer =
+        buffer->GetDataSize() - current_buffer_offset;
 
-    // |data| is NULL if we are seeking forward, so there's no need to copy.
-    if (data)
-      memcpy(data + taken, buffer->GetData() + current_buffer_offset, copied);
+    if (bytes_to_skip == 0) {
+      // Find the right amount to copy from the current buffer referenced by
+      // |buffer|. We shall copy no more than |size| bytes in total and each
+      // single step copied no more than the current buffer size.
+      size_t copied = std::min(size - taken, remaining_bytes_in_buffer);
 
-    // Increase total number of bytes copied, which regulates when to end this
-    // loop.
-    taken += copied;
+      // |data| is NULL if we are seeking forward, so there's no need to copy.
+      if (data)
+        memcpy(data + taken, buffer->GetData() + current_buffer_offset, copied);
 
-    // We have read |copied| bytes from the current buffer. Advances the offset.
-    current_buffer_offset += copied;
+      // Increase total number of bytes copied, which regulates when to end this
+      // loop.
+      taken += copied;
+
+      // We have read |copied| bytes from the current buffer. Advances the
+      // offset.
+      current_buffer_offset += copied;
+    } else {
+      size_t skipped = std::min(remaining_bytes_in_buffer, bytes_to_skip);
+      current_buffer_offset += skipped;
+      bytes_to_skip -= skipped;
+    }
 
     // The buffer has been consumed.
     if (current_buffer_offset == buffer->GetDataSize()) {
       if (advance_position) {
         // Next buffer may not have timestamp, so we need to update current
         // timestamp before switching to the next buffer.
         UpdateCurrentTime(current_buffer, current_buffer_offset);
       }
 
       BufferQueue::iterator next = current_buffer;
@@ skipping 33 matching lines @@
       (*buffer)->GetTimestamp().InMicroseconds() > 0) {
     int64 time_offset = ((*buffer)->GetDuration().InMicroseconds() *
                          offset) / (*buffer)->GetDataSize();
 
     current_time_ = (*buffer)->GetTimestamp() +
         base::TimeDelta::FromMicroseconds(time_offset);
   }
 }
 
 }  // namespace media