Remove AudioBuffer::set_duration(), instead base on frames.

media/base/audio_splicer.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/audio_splicer.h"
 
 #include <cstdlib>
 #include <deque>
 
 #include "base/logging.h"
@@ skipping 17 matching lines @@
 // in the source content. Unit is frames.
 static const int kMinGapSize = 2;
 
 // AudioBuffer::TrimStart() is not as accurate as the timestamp helper, so
 // manually adjust the duration and timestamp after trimming.
 static void AccurateTrimStart(int frames_to_trim,
                               const scoped_refptr<AudioBuffer> buffer,
                               const AudioTimestampHelper& timestamp_helper) {
   buffer->TrimStart(frames_to_trim);
   buffer->set_timestamp(timestamp_helper.GetTimestamp());
-  buffer->set_duration(
-      timestamp_helper.GetFrameDuration(buffer->frame_count()));
-}
-
-// AudioBuffer::TrimEnd() is not as accurate as the timestamp helper, so
-// manually adjust the duration after trimming.
-static void AccurateTrimEnd(int frames_to_trim,
-                            const scoped_refptr<AudioBuffer> buffer,
-                            const AudioTimestampHelper& timestamp_helper) {
-  DCHECK_LT(std::abs(timestamp_helper.GetFramesToTarget(buffer->timestamp())),
-            kMinGapSize);
-  buffer->TrimEnd(frames_to_trim);
-  buffer->set_duration(
-      timestamp_helper.GetFrameDuration(buffer->frame_count()));
 }
 
 // Returns an AudioBus whose frame buffer is backed by the provided AudioBuffer.
 static scoped_ptr<AudioBus> CreateAudioBufferWrapper(
     const scoped_refptr<AudioBuffer>& buffer) {
   scoped_ptr<AudioBus> wrapper =
       AudioBus::CreateWrapper(buffer->channel_count());
   wrapper->set_frames(buffer->frame_count());
   for (int ch = 0; ch < buffer->channel_count(); ++ch) {
     wrapper->SetChannelData(
@@ skipping 108 matching lines @@
     AddOutputBuffer(input);
     return true;
   }
 
   if (frames_to_fill > 0) {
     DVLOG(1) << "Gap detected @ " << expected_timestamp.InMicroseconds()
              << " us: " << delta.InMicroseconds() << " us";
 
     // Create a buffer with enough silence samples to fill the gap and
     // add it to the output buffer.
-    scoped_refptr<AudioBuffer> gap = AudioBuffer::CreateEmptyBuffer(
-        input->channel_layout(),
-        input->channel_count(),
-        input->sample_rate(),
-        frames_to_fill,
-        expected_timestamp,
-        output_timestamp_helper_.GetFrameDuration(frames_to_fill));
+    scoped_refptr<AudioBuffer> gap =
+        AudioBuffer::CreateEmptyBuffer(input->channel_layout(),
+                                       input->channel_count(),
+                                       input->sample_rate(),
+                                       frames_to_fill,
+                                       expected_timestamp);
     AddOutputBuffer(gap);
 
     // Add the input buffer now that the gap has been filled.
     AddOutputBuffer(input);
     return true;
   }
 
   // Overlapping buffers marked as splice frames are handled by AudioSplicer,
   // but decoder and demuxer quirks may sometimes produce overlapping samples
   // which need to be sanitized.
@@ skipping 239 matching lines @@
     const int frames_to_read =
         std::min(preroll->frame_count() - frames_before_splice,
                  output_bus->frames() - frames_read);
     preroll->ReadFrames(
         frames_to_read, frames_before_splice, frames_read, output_bus.get());
     frames_read += frames_to_read;
 
     // If only part of the buffer was consumed, trim it appropriately and stick
     // it into the output queue.
     if (frames_before_splice) {
-      AccurateTrimEnd(preroll->frame_count() - frames_before_splice,
-                      preroll,
-                      output_ts_helper);
+      preroll->TrimEnd(preroll->frame_count() - frames_before_splice);
       CHECK(output_sanitizer_->AddInput(preroll));
       frames_before_splice = 0;
     }
   }
 
   // All necessary buffers have been processed, it's safe to reset.
   pre_splice_sanitizer_->Reset();
   DCHECK_EQ(output_bus->frames(), frames_read);
   DCHECK_EQ(output_ts_helper.GetFramesToTarget(splice_timestamp_), 0);
   return output_bus.Pass();
 }
 
 void AudioSplicer::CrossfadePostSplice(
     scoped_ptr<AudioBus> pre_splice_bus,
     scoped_refptr<AudioBuffer> crossfade_buffer) {
   // Use the calculated timestamp and duration to ensure there's no extra gaps
   // or overlaps to process when adding the buffer to |output_sanitizer_|.
   const AudioTimestampHelper& output_ts_helper =
       output_sanitizer_->timestamp_helper();
   crossfade_buffer->set_timestamp(output_ts_helper.GetTimestamp());
-  crossfade_buffer->set_duration(
-      output_ts_helper.GetFrameDuration(pre_splice_bus->frames()));
 
   // AudioBuffer::ReadFrames() only allows output into an AudioBus, so wrap
   // our AudioBuffer in one so we can avoid extra data copies.
   scoped_ptr<AudioBus> output_bus = CreateAudioBufferWrapper(crossfade_buffer);
 
   // Extract crossfade section from the |post_splice_sanitizer_|.
   int frames_read = 0, frames_to_trim = 0;
   scoped_refptr<AudioBuffer> remainder;
   while (post_splice_sanitizer_->HasNextBuffer() &&
          frames_read < output_bus->frames()) {
@@ skipping 30 matching lines @@
     AccurateTrimStart(frames_to_trim, remainder, output_ts_helper);
     CHECK(output_sanitizer_->AddInput(remainder));
   }
 
   // Transfer all remaining buffers out and reset once empty.
   CHECK(post_splice_sanitizer_->DrainInto(output_sanitizer_.get()));
   post_splice_sanitizer_->Reset();
 }
 
 }  // namespace media