Introduce AudioOutputResampler for browser side resampling.

media/base/audio_fifo.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_fifo.h"
 
 #include "media/audio/audio_parameters.h"
 #include "base/logging.h"
 
 namespace media {
@@ skipping 17 matching lines @@
 
 AudioFifo::AudioFifo(int channels, int frames)
     : audio_bus_(AudioBus::Create(channels, frames)),
       max_frames_in_fifo_(frames),
       frames_in_fifo_(0),
       read_pos_(0),
       write_pos_(0) {}
 
 AudioFifo::~AudioFifo() {}
 
-bool AudioFifo::Push(const AudioBus* source) {
+bool AudioFifo::Push(const AudioBus* source, int frames) {
   DCHECK(source);
   DCHECK_EQ(source->channels(), audio_bus_->channels());
 
   // Ensure that there is space for the new data in the FIFO.
-  const int source_size = source->frames();
+  const int source_size = frames;
   if (frames_in_fifo_ + source_size > max_frames()) {
     DLOG(ERROR) << "FIFO overflow.";
     return false;
   }
 
   // Figure out if wrapping is needed and if so what segment sizes we need
   // when adding the new audio bus content to the FIFO.
   int append_size = 0;
   int wrap_size = 0;
   GetSizes(write_pos_, max_frames(), source_size, &append_size, &wrap_size);
@@ skipping 10 matching lines @@
       memcpy(&dest[0], &src[append_size], wrap_size * sizeof(src[0]));
     }
   }
 
   frames_in_fifo_ += source_size;
   DCHECK_LE(frames_in_fifo_, max_frames());
   write_pos_ = UpdatePos(write_pos_, source_size, max_frames());
   return true;
 }
 
-bool AudioFifo::Consume(AudioBus* destination, int frames_to_consume) {
+bool AudioFifo::Consume(AudioBus* destination, int start_frame,
+                        int frames_to_consume) {
   DCHECK(destination);
   DCHECK_EQ(destination->channels(), audio_bus_->channels());
 
   // It is not possible to ask for more data than what is available in the FIFO.
   if (frames_to_consume > frames_in_fifo_) {
     DLOG(ERROR) << "FIFO underrun.";
     return false;
   }
 
   // A copy from the FIFO to |destination| will only be performed if the
   // allocated memory in |destination| is sufficient.
-  if (frames_to_consume > destination->frames()) {
-    DLOG(ERROR) << "Insufficient space in destination.";
+  if (frames_to_consume + start_frame > destination->frames()) {
+    LOG(ERROR) << "Insufficient space in destination.";
     return false;
   }
 
   // Figure out if wrapping is needed and if so what segment sizes we need
   // when removing audio bus content from the FIFO.
   int consume_size = 0;
   int wrap_size = 0;
   GetSizes(read_pos_, max_frames(), frames_to_consume,
            &consume_size, &wrap_size);
 
   // For all channels, remove the requested amount of data from the FIFO
   // and copy the content to the destination. Wrap around if needed.
   for (int ch = 0; ch < destination->channels(); ++ch) {
     float* dest = destination->channel(ch);
     const float* src = audio_bus_->channel(ch);
 
     // Copy a selected part of the FIFO to the destination.
-    memcpy(&dest[0], &src[read_pos_], consume_size * sizeof(src[0]));
+    memcpy(&dest[start_frame], &src[read_pos_], consume_size * sizeof(src[0]));
     if (wrap_size > 0) {
       // Wrapping is needed: copy remaining part to the destination.
-      memcpy(&dest[consume_size], &src[0], wrap_size * sizeof(src[0]));
+      memcpy(&dest[consume_size + start_frame], &src[0],
+             wrap_size * sizeof(src[0]));
     }
   }
 
   frames_in_fifo_ -= frames_to_consume;
   read_pos_ = UpdatePos(read_pos_, frames_to_consume, max_frames());
   return true;
 }
 
 void AudioFifo::Clear() {
   frames_in_fifo_ = 0;
   read_pos_ = 0;
   write_pos_ = 0;
 }
 
 }  // namespace media