147 lines
3.9 KiB
C++
147 lines
3.9 KiB
C++
/*
|
|
* Copyright 2003-2019 The Music Player Daemon Project
|
|
* http://www.musicpd.org
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#ifndef MPD_PCM_REST_BUFFER_HXX
|
|
#define MPD_PCM_REST_BUFFER_HXX
|
|
|
|
#include "ChannelDefs.hxx"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <assert.h>
|
|
#include <stddef.h>
|
|
|
|
template<typename T> struct ConstBuffer;
|
|
class PcmBuffer;
|
|
|
|
/**
|
|
* A buffer which helps with conversion classes which need to handle
|
|
* multiple frames at a time; it stores the rest of a previous
|
|
* operation in order to use it in the next call.
|
|
*/
|
|
template<typename T, unsigned n_frames>
|
|
class PcmRestBuffer {
|
|
unsigned size, capacity;
|
|
T data[n_frames * MAX_CHANNELS];
|
|
|
|
public:
|
|
void Open(unsigned channels) noexcept {
|
|
assert(audio_valid_channel_count(channels));
|
|
|
|
capacity = n_frames * channels;
|
|
size = 0;
|
|
}
|
|
|
|
/**
|
|
* @return the size of one input block in #T samples
|
|
*/
|
|
size_t GetInputBlockSize() const noexcept {
|
|
return capacity;
|
|
}
|
|
|
|
unsigned GetChannelCount() const noexcept {
|
|
return capacity / n_frames;
|
|
}
|
|
|
|
void Reset() noexcept {
|
|
assert(audio_valid_channel_count(capacity / n_frames));
|
|
|
|
size = 0;
|
|
}
|
|
|
|
private:
|
|
ConstBuffer<T> Complete(ConstBuffer<T> &src) noexcept {
|
|
assert(audio_valid_channel_count(GetChannelCount()));
|
|
assert(src.size % GetChannelCount() == 0);
|
|
|
|
if (size == 0)
|
|
return nullptr;
|
|
|
|
size_t missing = capacity - size;
|
|
size_t n = std::min(missing, src.size);
|
|
std::copy_n(src.begin(), n, &data[size]);
|
|
src.skip_front(n);
|
|
size += n;
|
|
|
|
if (size < capacity)
|
|
return nullptr;
|
|
|
|
size = 0;
|
|
return {data, capacity};
|
|
}
|
|
|
|
void Append(ConstBuffer<T> src) noexcept {
|
|
assert(audio_valid_channel_count(GetChannelCount()));
|
|
assert(src.size % GetChannelCount() == 0);
|
|
assert(size + src.size < capacity);
|
|
|
|
std::copy_n(src.begin(), src.size, &data[size]);
|
|
size += src.size;
|
|
}
|
|
|
|
public:
|
|
/**
|
|
* A helper function which attempts to complete the rest
|
|
* buffer, allocates a destination buffer and invokes the
|
|
* given function for both the rest buffer and the new source
|
|
* buffer. In the end, it copies more remaining data to the
|
|
* rest buffer.
|
|
*
|
|
* @param U the destination data type
|
|
* @param F the inner process function
|
|
* @param dest_block_size how many destination samples in one block?
|
|
* @return the destination buffer (allocated from #buffer);
|
|
* may be empty
|
|
*/
|
|
template<typename U, typename F>
|
|
ConstBuffer<U> Process(PcmBuffer &buffer, ConstBuffer<T> src,
|
|
size_t dest_block_size,
|
|
F &&f) {
|
|
assert(dest_block_size % GetChannelCount() == 0);
|
|
|
|
const auto previous_rest = Complete(src);
|
|
assert(previous_rest.size == 0 ||
|
|
previous_rest.size == capacity);
|
|
|
|
const size_t previous_rest_blocks = !previous_rest.empty();
|
|
const size_t src_blocks = src.size / capacity;
|
|
const size_t next_rest_samples = src.size % capacity;
|
|
const size_t dest_blocks = previous_rest_blocks + src_blocks;
|
|
const size_t dest_samples = dest_blocks * dest_block_size;
|
|
|
|
const auto dest0 = buffer.GetT<U>(dest_samples);
|
|
auto dest = dest0;
|
|
|
|
if (!previous_rest.empty()) {
|
|
f(dest, previous_rest.data, previous_rest_blocks);
|
|
dest += dest_block_size;
|
|
}
|
|
|
|
f(dest, src.data, src_blocks);
|
|
|
|
if (next_rest_samples > 0)
|
|
Append({src.data + src_blocks * capacity,
|
|
next_rest_samples});
|
|
|
|
return { dest0, dest_samples };
|
|
}
|
|
};
|
|
|
|
#endif
|