Add support for complete buffer discards.

media/base/audio_discard_helper.cc

 // Copyright 2014 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/audio_discard_helper.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/audio_buffer.h"
@@ skipping 68 matching lines @@
     }
     return false;
   }
 
   const size_t original_frame_count = decoded_buffer->frame_count();
 
   // If there's a one buffer delay for decoding, pick up the last encoded
   // buffer's discard padding for processing with the current decoded buffer.
   DecoderBuffer::DiscardPadding current_discard_padding =
       encoded_buffer->discard_padding();
-  if (delayed_discard_)
+  if (delayed_discard_) {
+    // For simplicity disallow cases where decoder delay is present with delayed
+    // discard (no codecs at present).  Doing so allows us to avoid complexity
+    // around endpoint tracking when handling complete buffer discards.
+    DCHECK_EQ(decoder_delay_, 0u);
     std::swap(current_discard_padding, delayed_discard_padding_);
+  }
 
   if (discard_frames_ > 0) {
     const size_t decoded_frames = decoded_buffer->frame_count();
     const size_t frames_to_discard = std::min(discard_frames_, decoded_frames);
     discard_frames_ -= frames_to_discard;
 
     // If everything would be discarded, indicate a new buffer is required.
     if (frames_to_discard == decoded_frames) {
       // For simplicity disallow cases where a buffer with discard padding is
       // present.  Doing so allows us to avoid complexity around tracking
       // discards across buffers.
       DCHECK(current_discard_padding.first == base::TimeDelta());
       DCHECK(current_discard_padding.second == base::TimeDelta());
       return false;
     }
 
     decoded_buffer->TrimStart(frames_to_discard);
   }
 
   // Handle front discard padding.
   if (current_discard_padding.first > base::TimeDelta()) {
     const size_t decoded_frames = decoded_buffer->frame_count();
+
+    // If a complete buffer discard is requested and there's no decoder delay,
+    // just discard all remaining frames from this buffer.  With decoder delay
+    // we have to estimate the correct number of frames to discard based on the
+    // duration of the encoded buffer.
     const size_t start_frames_to_discard =
-        TimeDeltaToFrames(current_discard_padding.first);
+        current_discard_padding.first == kInfiniteDuration()
+            ? (decoder_delay_ > 0
+                   ? TimeDeltaToFrames(encoded_buffer->duration())
+                   : decoded_frames)
+            : TimeDeltaToFrames(current_discard_padding.first);
 
     // Regardless of the timestamp on the encoded buffer, the corresponding
     // decoded output will appear |decoder_delay_| frames later.
     size_t discard_start = decoder_delay_;
     if (decoder_delay_ > 0) {
       // If we have a |decoder_delay_| and have already discarded frames from
       // this buffer, the |discard_start| must be adjusted by the number of
       // frames already discarded.
       const size_t frames_discarded_so_far =
           original_frame_count - decoded_buffer->frame_count();
@@ skipping 51 matching lines @@
     DCHECK(current_discard_padding.second == base::TimeDelta());
   }
 
   // Assign timestamp to the buffer.
   decoded_buffer->set_timestamp(timestamp_helper_.GetTimestamp());
   timestamp_helper_.AddFrames(decoded_buffer->frame_count());
   return true;
 }
 
 }  // namespace media