media/base/audio_block_fifo.cc

   1 // Copyright 2014 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 <algorithm>
   6
   7 #include "media/base/audio_block_fifo.h"
   8
   9 #include "base/logging.h"
  10
  11 namespace media {
  12
  13 AudioBlockFifo::AudioBlockFifo(int channels, int frames, int blocks)
  14     : channels_(channels),
  15       block_frames_(frames),
  16       write_block_(0),
  17       read_block_(0),
  18       available_blocks_(0),
  19       write_pos_(0) {
  20   IncreaseCapacity(blocks);
  21 }
  22
  23 AudioBlockFifo::~AudioBlockFifo() {}
  24
  25 void AudioBlockFifo::Push(const void* source,
  26                           int frames,
  27                           int bytes_per_sample) {
  28   DCHECK(source);
  29   DCHECK_GT(frames, 0);
  30   DCHECK_GT(bytes_per_sample, 0);
  31   DCHECK_LT(available_blocks_, static_cast<int>(audio_blocks_.size()));
  32   CHECK_LE(frames, GetUnfilledFrames());
  33
  34   const uint8* source_ptr = static_cast<const uint8*>(source);
  35   int frames_to_push = frames;
  36   while (frames_to_push) {
  37     // Get the current write block.
  38     AudioBus* current_block = audio_blocks_[write_block_];
  39
  40     // Figure out what segment sizes we need when adding the new content to
  41     // the FIFO.
  42     const int push_frames =
  43         std::min(block_frames_ - write_pos_, frames_to_push);
  44
  45     // Deinterleave the content to the FIFO and update the |write_pos_|.
  46     current_block->FromInterleavedPartial(
  47         source_ptr, write_pos_, push_frames, bytes_per_sample);
  48     write_pos_ = (write_pos_ + push_frames) % block_frames_;
  49     if (!write_pos_) {
  50       // The current block is completely filled, increment |write_block_| and
  51       // |available_blocks_|.
  52       write_block_ = (write_block_ + 1) % audio_blocks_.size();
  53       ++available_blocks_;
  54     }
  55
  56     source_ptr += push_frames * bytes_per_sample * channels_;
  57     frames_to_push -= push_frames;
  58     DCHECK_GE(frames_to_push, 0);
  59   }
  60 }
  61
  62 const AudioBus* AudioBlockFifo::Consume() {
  63   DCHECK(available_blocks_);
  64   AudioBus* audio_bus = audio_blocks_[read_block_];
  65   read_block_ = (read_block_ + 1) % audio_blocks_.size();
  66   --available_blocks_;
  67   return audio_bus;
  68 }
  69
  70 void AudioBlockFifo::Clear() {
  71   write_pos_ = 0;
  72   write_block_ = 0;
  73   read_block_ = 0;
  74   available_blocks_ = 0;
  75 }
  76
  77 int AudioBlockFifo::GetAvailableFrames() const {
  78   return available_blocks_ * block_frames_ + write_pos_;
  79 }
  80
  81 int AudioBlockFifo::GetUnfilledFrames() const {
  82   const int unfilled_frames =
  83       (audio_blocks_.size() - available_blocks_) * block_frames_ - write_pos_;
  84   DCHECK_GE(unfilled_frames, 0);
  85   return unfilled_frames;
  86 }
  87
  88 void AudioBlockFifo::IncreaseCapacity(int blocks) {
  89   DCHECK_GT(blocks, 0);
  90
  91   // Create |blocks| of audio buses and insert them to the containers.
  92   audio_blocks_.reserve(audio_blocks_.size() + blocks);
  93
  94   const int original_size = audio_blocks_.size();
  95   for (int i = 0; i < blocks; ++i) {
  96     audio_blocks_.push_back(
  97         AudioBus::Create(channels_, block_frames_).release());
  98   }
  99
 100   if (!original_size)
 101     return;
 102
 103   std::rotate(audio_blocks_.begin() + read_block_,
 104               audio_blocks_.begin() + original_size,
 105               audio_blocks_.end());
 106
 107   // Update the write pointer if it is on top of the new inserted blocks.
 108   if (write_block_ >= read_block_)
 109     write_block_ += blocks;
 110
 111   // Update the read pointers correspondingly.
 112   read_block_ += blocks;
 113
 114   DCHECK_LT(read_block_, static_cast<int>(audio_blocks_.size()));
 115   DCHECK_LT(write_block_, static_cast<int>(audio_blocks_.size()));
 116 }
 117
 118 }  // namespace media