itsmattkc
6f0d72c05d
While planar audio cannot be used for playback, it's much easier for processing. This should lead to cleaner and easier to write code in the future.
78 lines
2.9 KiB
C++
78 lines
2.9 KiB
C++
#include "audioworker.h"
|
|
|
|
AudioWorker::AudioWorker(DecoderCache* decoder_cache, QHash<Node *, Node *> *copy_map, QObject *parent) :
|
|
AudioRenderWorker(decoder_cache, copy_map, parent)
|
|
{
|
|
}
|
|
|
|
void AudioWorker::FrameToValue(DecoderPtr decoder, StreamPtr stream, const TimeRange &range, NodeValueTable* table)
|
|
{
|
|
if (stream->type() != Stream::kAudio) {
|
|
return;
|
|
}
|
|
|
|
if (decoder->HasConformedVersion(audio_params())) {
|
|
SampleBufferPtr frame = decoder->RetrieveAudio(range.in(), range.out() - range.in(), audio_params());
|
|
|
|
if (frame) {
|
|
table->Push(NodeParam::kSamples, QVariant::fromValue(frame));
|
|
}
|
|
} else {
|
|
emit ConformUnavailable(decoder->stream(), CurrentPath().range(), range.out(), audio_params());
|
|
}
|
|
}
|
|
|
|
void AudioWorker::RunNodeAccelerated(const Node *node, const TimeRange &range, const NodeValueDatabase &input_params_in, NodeValueTable *output_params)
|
|
{
|
|
// Check if node processes samples
|
|
if (!(node->GetCapabilities(input_params_in) & Node::kSampleProcessor)) {
|
|
return;
|
|
}
|
|
|
|
// Copy database so we can make some temporary modifications to it
|
|
NodeValueDatabase input_params = input_params_in;
|
|
|
|
// Try to find the sample buffer in the table
|
|
QVariant samples_var = input_params[node->ProcessesSamplesFrom()].Get(NodeParam::kSamples);
|
|
|
|
// If there isn't one, there's nothing to do
|
|
if (samples_var.isNull()) {
|
|
return;
|
|
}
|
|
|
|
SampleBufferPtr input_buffer = samples_var.value<SampleBufferPtr>();
|
|
SampleBufferPtr output_buffer = SampleBuffer::CreateAllocated(input_buffer->audio_params(), input_buffer->sample_count_per_channel());
|
|
|
|
int sample_count = input_buffer->sample_count_per_channel();
|
|
|
|
// FIXME: Hardcoded float sample format
|
|
for (int i=0;i<sample_count;i++) {
|
|
// Calculate the exact rational time at this sample
|
|
int sample_out_of_channel = i / audio_params().channel_count();
|
|
double sample_to_second = static_cast<double>(sample_out_of_channel) / static_cast<double>(audio_params().sample_rate());
|
|
|
|
rational this_sample_time = rational::fromDouble(range.in().toDouble() + sample_to_second);
|
|
|
|
// Update all non-sample and non-footage inputs
|
|
foreach (NodeParam* param, node->parameters()) {
|
|
if (param->type() == NodeParam::kInput
|
|
&& param != node->ProcessesSamplesFrom()) {
|
|
NodeInput* input = static_cast<NodeInput*>(param);
|
|
|
|
// If the input isn't keyframing, we don't need to update it unless it's connected, in which case it may change
|
|
if (input->IsConnected() || input->is_keyframing()) {
|
|
input_params.Insert(input, ProcessInput(input, TimeRange(this_sample_time, this_sample_time)));
|
|
}
|
|
}
|
|
}
|
|
|
|
node->ProcessSamples(&input_params,
|
|
audio_params(),
|
|
input_buffer,
|
|
output_buffer,
|
|
i);
|
|
}
|
|
|
|
output_params->Push(NodeParam::kSamples, QVariant::fromValue(output_buffer));
|
|
}
|