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