audio_buffer_converter.cc revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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 "media/base/audio_buffer_converter.h"
6
7#include <cmath>
8
9#include "base/logging.h"
10#include "media/base/audio_buffer.h"
11#include "media/base/audio_bus.h"
12#include "media/base/audio_decoder_config.h"
13#include "media/base/audio_timestamp_helper.h"
14#include "media/base/buffers.h"
15#include "media/base/sinc_resampler.h"
16#include "media/base/vector_math.h"
17
18namespace media {
19
20// Is the config presented by |buffer| a config change from |params|?
21static bool IsConfigChange(const AudioParameters& params,
22                           const scoped_refptr<AudioBuffer>& buffer) {
23  return buffer->sample_rate() != params.sample_rate() ||
24         buffer->channel_count() != params.channels() ||
25         buffer->channel_layout() != params.channel_layout();
26}
27
28AudioBufferConverter::AudioBufferConverter(const AudioParameters& output_params)
29    : output_params_(output_params),
30      input_params_(output_params),
31      last_input_buffer_offset_(0),
32      input_frames_(0),
33      buffered_input_frames_(0.0),
34      io_sample_rate_ratio_(1.0),
35      timestamp_helper_(output_params_.sample_rate()),
36      is_flushing_(false) {}
37
38AudioBufferConverter::~AudioBufferConverter() {}
39
40void AudioBufferConverter::AddInput(const scoped_refptr<AudioBuffer>& buffer) {
41  // On EOS flush any remaining buffered data.
42  if (buffer->end_of_stream()) {
43    Flush();
44    queued_outputs_.push_back(buffer);
45    return;
46  }
47
48  // We'll need a new |audio_converter_| if there was a config change.
49  if (IsConfigChange(input_params_, buffer))
50    ResetConverter(buffer);
51
52  // Pass straight through if there's no work to be done.
53  if (!audio_converter_) {
54    queued_outputs_.push_back(buffer);
55    return;
56  }
57
58  if (timestamp_helper_.base_timestamp() == kNoTimestamp())
59    timestamp_helper_.SetBaseTimestamp(buffer->timestamp());
60
61  queued_inputs_.push_back(buffer);
62  input_frames_ += buffer->frame_count();
63
64  ConvertIfPossible();
65}
66
67bool AudioBufferConverter::HasNextBuffer() { return !queued_outputs_.empty(); }
68
69scoped_refptr<AudioBuffer> AudioBufferConverter::GetNextBuffer() {
70  DCHECK(!queued_outputs_.empty());
71  scoped_refptr<AudioBuffer> out = queued_outputs_.front();
72  queued_outputs_.pop_front();
73  return out;
74}
75
76void AudioBufferConverter::Reset() {
77  audio_converter_.reset();
78  queued_inputs_.clear();
79  queued_outputs_.clear();
80  timestamp_helper_.SetBaseTimestamp(kNoTimestamp());
81  input_params_ = output_params_;
82  input_frames_ = 0;
83  buffered_input_frames_ = 0.0;
84  last_input_buffer_offset_ = 0;
85}
86
87void AudioBufferConverter::ResetTimestampState() {
88  Flush();
89  timestamp_helper_.SetBaseTimestamp(kNoTimestamp());
90}
91
92double AudioBufferConverter::ProvideInput(AudioBus* audio_bus,
93                                          base::TimeDelta buffer_delay) {
94  DCHECK(is_flushing_ || input_frames_ >= audio_bus->frames());
95
96  int requested_frames_left = audio_bus->frames();
97  int dest_index = 0;
98
99  while (requested_frames_left > 0 && !queued_inputs_.empty()) {
100    scoped_refptr<AudioBuffer> input_buffer = queued_inputs_.front();
101
102    int frames_to_read =
103        std::min(requested_frames_left,
104                 input_buffer->frame_count() - last_input_buffer_offset_);
105    input_buffer->ReadFrames(
106        frames_to_read, last_input_buffer_offset_, dest_index, audio_bus);
107    last_input_buffer_offset_ += frames_to_read;
108
109    if (last_input_buffer_offset_ == input_buffer->frame_count()) {
110      // We've consumed all the frames in |input_buffer|.
111      queued_inputs_.pop_front();
112      last_input_buffer_offset_ = 0;
113    }
114
115    requested_frames_left -= frames_to_read;
116    dest_index += frames_to_read;
117  }
118
119  // If we're flushing, zero any extra space, otherwise we should always have
120  // enough data to completely fulfill the request.
121  if (is_flushing_ && requested_frames_left > 0) {
122    audio_bus->ZeroFramesPartial(audio_bus->frames() - requested_frames_left,
123                                 requested_frames_left);
124  } else {
125    DCHECK_EQ(requested_frames_left, 0);
126  }
127
128  input_frames_ -= audio_bus->frames() - requested_frames_left;
129  DCHECK_GE(input_frames_, 0);
130
131  buffered_input_frames_ += audio_bus->frames() - requested_frames_left;
132
133  // Full volume.
134  return 1.0;
135}
136
137void AudioBufferConverter::ResetConverter(
138    const scoped_refptr<AudioBuffer>& buffer) {
139  Flush();
140  audio_converter_.reset();
141  input_params_.Reset(
142      input_params_.format(),
143      buffer->channel_layout(),
144      buffer->channel_count(),
145      buffer->sample_rate(),
146      input_params_.bits_per_sample(),
147      // If resampling is needed and the FIFO disabled, the AudioConverter will
148      // always request SincResampler::kDefaultRequestSize frames.  Otherwise it
149      // will use the output frame size.
150      buffer->sample_rate() == output_params_.sample_rate()
151          ? output_params_.frames_per_buffer()
152          : SincResampler::kDefaultRequestSize);
153
154  io_sample_rate_ratio_ = static_cast<double>(input_params_.sample_rate()) /
155                          output_params_.sample_rate();
156
157  // If |buffer| matches |output_params_| we don't need an AudioConverter at
158  // all, and can early-out here.
159  if (!IsConfigChange(output_params_, buffer))
160    return;
161
162  // Note: The FIFO is disabled to avoid extraneous memcpy().
163  audio_converter_.reset(
164      new AudioConverter(input_params_, output_params_, true));
165  audio_converter_->AddInput(this);
166}
167
168void AudioBufferConverter::ConvertIfPossible() {
169  DCHECK(audio_converter_);
170
171  int request_frames = 0;
172
173  if (is_flushing_) {
174    // If we're flushing we want to convert *everything* even if this means
175    // we'll have to pad some silence in ProvideInput().
176    request_frames =
177        ceil((buffered_input_frames_ + input_frames_) / io_sample_rate_ratio_);
178  } else {
179    // How many calls to ProvideInput() we can satisfy completely.
180    int chunks = input_frames_ / input_params_.frames_per_buffer();
181
182    // How many output frames that corresponds to:
183    request_frames = chunks * audio_converter_->ChunkSize();
184  }
185
186  if (!request_frames)
187    return;
188
189  scoped_refptr<AudioBuffer> output_buffer =
190      AudioBuffer::CreateBuffer(kSampleFormatPlanarF32,
191                                output_params_.channel_layout(),
192                                output_params_.channels(),
193                                output_params_.sample_rate(),
194                                request_frames);
195  scoped_ptr<AudioBus> output_bus =
196      AudioBus::CreateWrapper(output_buffer->channel_count());
197
198  int frames_remaining = request_frames;
199
200  // The AudioConverter wants requests of a fixed size, so we'll slide an
201  // AudioBus of that size across the |output_buffer|.
202  while (frames_remaining != 0) {
203    // It's important that this is a multiple of AudioBus::kChannelAlignment in
204    // all requests except for the last, otherwise downstream SIMD optimizations
205    // will crash on unaligned data.
206    const int frames_this_iteration = std::min(
207        static_cast<int>(SincResampler::kDefaultRequestSize), frames_remaining);
208    const int offset_into_buffer =
209        output_buffer->frame_count() - frames_remaining;
210
211    // Wrap the portion of the AudioBuffer in an AudioBus so the AudioConverter
212    // can fill it.
213    output_bus->set_frames(frames_this_iteration);
214    for (int ch = 0; ch < output_buffer->channel_count(); ++ch) {
215      output_bus->SetChannelData(
216          ch,
217          reinterpret_cast<float*>(output_buffer->channel_data()[ch]) +
218              offset_into_buffer);
219    }
220
221    // Do the actual conversion.
222    audio_converter_->Convert(output_bus.get());
223    frames_remaining -= frames_this_iteration;
224    buffered_input_frames_ -= frames_this_iteration * io_sample_rate_ratio_;
225  }
226
227  // Compute the timestamp.
228  output_buffer->set_timestamp(timestamp_helper_.GetTimestamp());
229  timestamp_helper_.AddFrames(request_frames);
230
231  queued_outputs_.push_back(output_buffer);
232}
233
234void AudioBufferConverter::Flush() {
235  if (!audio_converter_)
236    return;
237  is_flushing_ = true;
238  ConvertIfPossible();
239  is_flushing_ = false;
240  audio_converter_->Reset();
241  DCHECK_EQ(input_frames_, 0);
242  DCHECK_EQ(last_input_buffer_offset_, 0);
243  DCHECK_LT(buffered_input_frames_, 1.0);
244  DCHECK(queued_inputs_.empty());
245  buffered_input_frames_ = 0.0;
246}
247
248}  // namespace media
249