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
11namespace media {
12
13AudioBlockFifo::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
23AudioBlockFifo::~AudioBlockFifo() {}
24
25void 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
62const 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
70void AudioBlockFifo::Clear() {
71  write_pos_ = 0;
72  write_block_ = 0;
73  read_block_ = 0;
74  available_blocks_ = 0;
75}
76
77int AudioBlockFifo::GetAvailableFrames() const {
78  return available_blocks_ * block_frames_ + write_pos_;
79}
80
81int 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
88void 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
119