media/base/audio_fifo.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/base/audio_fifo.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace media {
  10
  11 // Given current position in the FIFO, the maximum number of elements in the
  12 // FIFO and the size of the input; this method provides two output results:
  13 // |size| and |wrap_size|. These two results can then be utilized for memcopy
  14 // operations to and from the FIFO.
  15 // Under "normal" circumstances, |size| will be equal to |in_size| and
  16 // |wrap_size| will be zero. This case corresponding to the non-wrapping case
  17 // where we have not yet reached the "edge" of the FIFO. If |pos| + |in_size|
  18 // exceeds the total size of the FIFO, we must wrap around and start reusing
  19 // a part the allocated memory. The size of this part is given by |wrap_size|.
  20 static void GetSizes(
  21     int pos, int max_size, int in_size, int* size, int* wrap_size) {
  22   if (pos + in_size > max_size) {
  23     // Wrapping is required => derive size of each segment.
  24     *size = max_size - pos;
  25     *wrap_size = in_size - *size;
  26   } else {
  27     // Wrapping is not required.
  28     *size = in_size;
  29     *wrap_size = 0;
  30   }
  31 }
  32
  33 // Updates the read/write position with |step| modulo the maximum number of
  34 // elements in the FIFO to ensure that the position counters wraps around at
  35 // the endpoint.
  36 static int UpdatePos(int pos, int step, int max_size) {
  37   return ((pos + step) % max_size);
  38 }
  39
  40 AudioFifo::AudioFifo(int channels, int frames)
  41     : audio_bus_(AudioBus::Create(channels, frames)),
  42       max_frames_(frames),
  43       frames_pushed_(0),
  44       frames_consumed_(0),
  45       read_pos_(0),
  46       write_pos_(0) {}
  47
  48 AudioFifo::~AudioFifo() {}
  49
  50 int AudioFifo::frames() const {
  51   int delta = frames_pushed_ - frames_consumed_;
  52   return delta;
  53 }
  54
  55 void AudioFifo::Push(const AudioBus* source) {
  56   DCHECK(source);
  57   DCHECK_EQ(source->channels(), audio_bus_->channels());
  58
  59   // Ensure that there is space for the new data in the FIFO.
  60   const int source_size = source->frames();
  61   CHECK_LE(source_size + frames(), max_frames_);
  62
  63   // Figure out if wrapping is needed and if so what segment sizes we need
  64   // when adding the new audio bus content to the FIFO.
  65   int append_size = 0;
  66   int wrap_size = 0;
  67   GetSizes(write_pos_, max_frames(), source_size, &append_size, &wrap_size);
  68
  69   // Copy all channels from the source to the FIFO. Wrap around if needed.
  70   for (int ch = 0; ch < source->channels(); ++ch) {
  71     float* dest = audio_bus_->channel(ch);
  72     const float* src = source->channel(ch);
  73
  74     // Append part of (or the complete) source to the FIFO.
  75     memcpy(&dest[write_pos_], &src[0], append_size * sizeof(src[0]));
  76     if (wrap_size > 0) {
  77       // Wrapping is needed: copy remaining part from the source to the FIFO.
  78       memcpy(&dest[0], &src[append_size], wrap_size * sizeof(src[0]));
  79     }
  80   }
  81
  82   frames_pushed_ += source_size;
  83   DCHECK_LE(frames(), max_frames());
  84   write_pos_ = UpdatePos(write_pos_, source_size, max_frames());
  85 }
  86
  87 void AudioFifo::Consume(AudioBus* destination,
  88                         int start_frame,
  89                         int frames_to_consume) {
  90   DCHECK(destination);
  91   DCHECK_EQ(destination->channels(), audio_bus_->channels());
  92
  93   // It is not possible to ask for more data than what is available in the FIFO.
  94   CHECK_LE(frames_to_consume, frames());
  95
  96   // A copy from the FIFO to |destination| will only be performed if the
  97   // allocated memory in |destination| is sufficient.
  98   CHECK_LE(frames_to_consume + start_frame, destination->frames());
  99
 100   // Figure out if wrapping is needed and if so what segment sizes we need
 101   // when removing audio bus content from the FIFO.
 102   int consume_size = 0;
 103   int wrap_size = 0;
 104   GetSizes(read_pos_, max_frames(), frames_to_consume,
 105            &consume_size, &wrap_size);
 106
 107   // For all channels, remove the requested amount of data from the FIFO
 108   // and copy the content to the destination. Wrap around if needed.
 109   for (int ch = 0; ch < destination->channels(); ++ch) {
 110     float* dest = destination->channel(ch);
 111     const float* src = audio_bus_->channel(ch);
 112
 113     // Copy a selected part of the FIFO to the destination.
 114     memcpy(&dest[start_frame], &src[read_pos_], consume_size * sizeof(src[0]));
 115     if (wrap_size > 0) {
 116       // Wrapping is needed: copy remaining part to the destination.
 117       memcpy(&dest[consume_size + start_frame], &src[0],
 118              wrap_size * sizeof(src[0]));
 119     }
 120   }
 121
 122   frames_consumed_ += frames_to_consume;
 123   read_pos_ = UpdatePos(read_pos_, frames_to_consume, max_frames());
 124 }
 125
 126 void AudioFifo::Clear() {
 127   frames_pushed_ = 0;
 128   frames_consumed_ = 0;
 129   read_pos_ = 0;
 130   write_pos_ = 0;
 131 }
 132
 133 }  // namespace media