Source code
Revision control
Copy as Markdown
/*
Copyright 2018 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS-IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#ifndef RESONANCE_AUDIO_GRAPH_BINAURAL_SURROUND_RENDERER_IMPL_H_
#define RESONANCE_AUDIO_GRAPH_BINAURAL_SURROUND_RENDERER_IMPL_H_
#include <memory>
#include <string>
#include "api/binaural_surround_renderer.h"
#include "api/resonance_audio_api.h"
#include "base/constants_and_types.h"
#include "utils/buffer_partitioner.h"
#include "utils/buffer_unpartitioner.h"
#include "utils/threadsafe_fifo.h"
namespace vraudio {
// Renders virtual surround sound as well as ambisonic soundfields to binaural
// stereo.
class BinauralSurroundRendererImpl : public BinauralSurroundRenderer {
public:
// Constructor.
//
// @param frames_per_buffer Number of frames in output buffer.
// @param sample_rate_hz Sample rate of audio buffers.
BinauralSurroundRendererImpl(size_t frames_per_buffer, int sample_rate_hz);
~BinauralSurroundRendererImpl() override{};
// Initializes surround sound decoding.
//
// @param surround_format Surround sound input format.
// @return True on success.
bool Init(SurroundFormat surround_format);
// Implements |AudioRenderer| interface.
void SetStereoSpeakerMode(bool enabled) override;
size_t GetNumAvailableFramesInInputBuffer() const override;
size_t AddInterleavedInput(const int16* input_buffer_ptr, size_t num_channels,
size_t num_frames) override;
size_t AddInterleavedInput(const float* input_buffer_ptr, size_t num_channels,
size_t num_frames) override;
size_t AddPlanarInput(const int16* const* input_buffer_ptrs,
size_t num_channels, size_t num_frames) override;
size_t AddPlanarInput(const float* const* input_buffer_ptrs,
size_t num_channels, size_t num_frames) override;
size_t GetAvailableFramesInStereoOutputBuffer() const override;
size_t GetInterleavedStereoOutput(int16* output_buffer_ptr,
size_t num_frames) override;
size_t GetInterleavedStereoOutput(float* output_buffer_ptr,
size_t num_frames) override;
size_t GetPlanarStereoOutput(int16** output_buffer_ptrs,
size_t num_frames) override;
size_t GetPlanarStereoOutput(float** output_buffer_ptrs,
size_t num_frames) override;
bool TriggerProcessing() override;
void Clear() override;
void SetHeadRotation(float w, float x, float y, float z) override;
protected:
// Protected default constructor for mock tests.
BinauralSurroundRendererImpl();
private:
// Callback triggered by |buffer_partitioner_| whenever a new |AudioBuffer|
// has been generated.
//
// @param processed_buffer Pointer to processed buffer.
// @return Pointer to next |AudioBuffer| to be filled up.
AudioBuffer* BufferPartitionerCallback(AudioBuffer* processed_buffer);
// Helper method to implement |AddInterleavedInput| independently from the
// sample type.
//
// @tparam BufferType Input buffer type.
// @param input_buffer_ptr Pointer to interleaved input data.
// @param num_channels Number of channels in input buffer.
// @param num_frames Number of frames in input buffer.
// @return The number of consumed samples.
template <typename BufferType>
size_t AddInputBufferTemplated(const BufferType input_buffer_ptr,
size_t num_channels, size_t num_frames);
// Helper method to implement |GetInterleavedOutput| independently from the
// sample type.
//
// @tparam BufferType Output buffer type.
// @param output_buffer_ptr Pointer to allocated interleaved output buffer.
// @param num_frames Size of output buffer in frames.
// @return The number of consumed frames.
template <typename BufferType>
size_t GetStereoOutputBufferTemplated(BufferType output_buffer_ptr,
size_t num_frames);
// Helper method to obtain the expected number of audio channels for a given
// surround format.
//
// @param surround_format Surround format query.
// @return Number of audio channels.
static size_t GetExpectedNumChannelsFromSurroundFormat(
SurroundFormat surround_format);
// Process method executed by |buffer_unpartitioner_|.
AudioBuffer* ProcessBuffer();
// Initializes binaural mono rendering.
void InitializeBinauralMono();
// Initializes binaural stereo rendering.
void InitializeBinauralStereo();
// Initializes binaural 5.1 rendering.
void InitializeBinauralSurround5dot1();
// Initializes binaural 7.1 rendering.
void InitializeBinauralSurround7dot1();
// Initializes binaural ambisonic rendering.
void InitializeAmbisonics();
// Initializes binaural ambisonic rendering with non-diegetic stereo.
void InitializeAmbisonicsWithNonDiegeticStereo();
// Creates a sound object at given angle within the horizontal listener plane.
SourceId CreateSoundObject(float azimuth_deg);
// Initializes room reverb for virtual surround sound rendering.
void InitializeRoomReverb();
// ResonanceAudioApi instance.
std::unique_ptr<ResonanceAudioApi> resonance_audio_api_;
// Frames per buffer.
const size_t frames_per_buffer_;
// System sample rate.
const int sample_rate_hz_;
// Selected surround sound format.
SurroundFormat surround_format_;
// Number of input channels.
size_t num_input_channels_;
// Partitions input buffers into |AudioBuffer|s.
std::unique_ptr<BufferPartitioner> buffer_partitioner_;
// Buffer queue containing partitioned input |AudioBuffer|s.
std::unique_ptr<ThreadsafeFifo<AudioBuffer>> input_audio_buffer_queue_;
// Binaural stereo output buffer.
AudioBuffer output_buffer_;
// Unpartitions processed |AudioBuffer|s into interleaved output buffers.
std::unique_ptr<BufferUnpartitioner> buffer_unpartitioner_;
// Vector containing the source ids of all rendered sound sources.
std::vector<SourceId> source_ids_;
// Total number of frames currently buffered.
size_t total_frames_buffered_;
// Total number of zero padded frames from |TriggerProcessing| calls.
size_t num_zero_padded_frames_;
// Temporary buffer to store pointers to planar ambisonic and stereo channels.
std::vector<const float*> temp_planar_buffer_ptrs_;
// Global output gain adjustment, to avoid clipping of individual channels
// in virtual speaker modes.
float output_gain_;
};
} // namespace vraudio
#endif // RESONANCE_AUDIO_GRAPH_BINAURAL_SURROUND_RENDERER_IMPL_H_