Add support for partial append window end trimming.

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 11 matching lines @@
                 << " ts " << current_timestamp.InMicroseconds() << " us"
                 << " diff " << diff.InMicroseconds() << " us";
 }
 
 AudioDiscardHelper::AudioDiscardHelper(int sample_rate, size_t decoder_delay)
     : sample_rate_(sample_rate),
       decoder_delay_(decoder_delay),
       timestamp_helper_(sample_rate_),
       discard_frames_(0),
       last_input_timestamp_(kNoTimestamp()),
-      delayed_discard_(false) {
+      delayed_discard_(false),
+      delayed_end_discard_(0) {
   DCHECK_GT(sample_rate_, 0);
 }
 
 AudioDiscardHelper::~AudioDiscardHelper() {
 }
 
 size_t AudioDiscardHelper::TimeDeltaToFrames(base::TimeDelta duration) const {
   DCHECK(duration >= base::TimeDelta());
   return duration.InSecondsF() * sample_rate_ + 0.5;
 }
@@ skipping 49 matching lines @@
     // 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;
 
+    DVLOG(1) << "Initial discard of " << frames_to_discard << " out of "
+             << decoded_frames << " frames.";
+
     // 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);
   }
 
+  // Process any delayed end discard from the previous buffer.
+  if (delayed_end_discard_ > 0) {
+    DCHECK_GT(decoder_delay_, 0u);
+    DCHECK_LT(delayed_end_discard_, decoder_delay_);
+
+    const size_t decoded_frames = decoded_buffer->frame_count();
+    const size_t frames_to_discard = decoder_delay_ - delayed_end_discard_;
+    DCHECK_LT(frames_to_discard, decoded_frames);
+
+    DVLOG(1) << "Delayed end discard of " << frames_to_discard << " out of "
+             << decoded_frames << " frames starting at "
+             << delayed_end_discard_;
+
+    decoded_buffer->TrimRange(delayed_end_discard_,
+                              delayed_end_discard_ + frames_to_discard);
+    delayed_end_discard_ = 0;
+  }
+
   // 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 =
         current_discard_padding.first == kInfiniteDuration()
@@ skipping 21 matching lines @@
     CHECK_LT(discard_start, decoded_frames);
 
     const size_t frames_to_discard =
         std::min(start_frames_to_discard, decoded_frames - discard_start);
 
     // Carry over any frames which need to be discarded from the front of the
     // next buffer.
     DCHECK(!discard_frames_);
     discard_frames_ = start_frames_to_discard - frames_to_discard;
 
+    DVLOG(1) << "Front discard of " << frames_to_discard << " out of "
+             << decoded_frames << " frames starting at " << discard_start;
+
     // If everything would be discarded, indicate a new buffer is required.
     if (frames_to_discard == decoded_frames) {
       // The buffer should not have been marked with end discard if the front
       // discard removes everything.
       DCHECK(current_discard_padding.second == base::TimeDelta());
       return false;
     }
 
     decoded_buffer->TrimRange(discard_start, discard_start + frames_to_discard);
   } else {
     DCHECK(current_discard_padding.first == base::TimeDelta());
   }
 
   // Handle end discard padding.
   if (current_discard_padding.second > base::TimeDelta()) {
-    // Limit end discarding to when there is no |decoder_delay_|, otherwise it's
-    // non-trivial determining where to start discarding end frames.
-    CHECK(!decoder_delay_);
+    const size_t decoded_frames = decoded_buffer->frame_count();
+    size_t end_frames_to_discard =
+        TimeDeltaToFrames(current_discard_padding.second);
 
-    const size_t decoded_frames = decoded_buffer->frame_count();
-    const size_t end_frames_to_discard =
-        TimeDeltaToFrames(current_discard_padding.second);
+    if (decoder_delay_) {
+      // Delayed end discard only works if the decoder delay is less than a
+      // single buffer.
+      DCHECK_LT(decoder_delay_, original_frame_count);

[acolwell GONE FROM CHROMIUM, 2014/07/23 00:15:42]

Will this blow up on Opus & Vorbis then?

[DaleCurtis, 2014/07/23 01:50:41]

No, they don't have any decoder delay; only MP3 does.

+
+      // If the discard is >= the decoder delay, trim everything we can off the
+      // end of this buffer and the rest from the start of the next.
+      if (end_frames_to_discard >= decoder_delay_) {
+        DCHECK(!discard_frames_);
+        discard_frames_ = decoder_delay_;
+        end_frames_to_discard = end_frames_to_discard - decoder_delay_;

[acolwell GONE FROM CHROMIUM, 2014/07/23 00:15:41]

nit: -= here?

[DaleCurtis, 2014/07/23 01:50:41]

Done.

+      } else {
+        delayed_end_discard_ = decoder_delay_ - end_frames_to_discard;
+        end_frames_to_discard = 0;
+      }
+    }
 
     if (end_frames_to_discard > decoded_frames) {
       DLOG(ERROR) << "Encountered invalid discard padding value.";
       return false;
     }
 
-    // If everything would be discarded, indicate a new buffer is required.
-    if (end_frames_to_discard == decoded_frames)
-      return false;
+    if (end_frames_to_discard > 0) {
+      DVLOG(1) << "End discard of " << end_frames_to_discard << " out of "
+               << decoded_frames;
 
-    decoded_buffer->TrimEnd(end_frames_to_discard);
+      // If everything would be discarded, indicate a new buffer is required.
+      if (end_frames_to_discard == decoded_frames)
+        return false;
+
+      decoded_buffer->TrimEnd(end_frames_to_discard);
+    }
   } else {
     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