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);
+
+      // 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 -= decoder_delay_;
+      } else {
+        delayed_end_discard_ = decoder_delay_ - end_frames_to_discard;

[acolwell GONE FROM CHROMIUM, 2014/07/24 19:22:14]

Can you just store end_frames_to_discard here and then rework the TrimRange()
computation in ProcessBuffers(). ISTM that would be easier to understand and
make the comment for this member variable less confusing. IIUC this is just
delaying the end discard amount until we receive the next buffer.

[DaleCurtis, 2014/07/29 01:35:09]

Done.

+        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