#include <ByteOrder.h>
#include <Buffer.h>
#include <BufferGroup.h>
#include <TimeSource.h>
#include <ParameterWeb.h>
#include <String.h>
#include <stdio.h>
#include <string.h>
#include "VSTNode.h"
VSTNode::~VSTNode()
{
Quit();
}
VSTNode::VSTNode(BMediaAddOn* addon, const char* name, const char* path)
:
BMediaNode(name),
BBufferConsumer(B_MEDIA_RAW_AUDIO),
BBufferProducer(B_MEDIA_RAW_AUDIO),
BControllable(),
BMediaEventLooper(),
fAddOn(addon),
fOutputMediaEnabled(true),
fDownstreamLatency(0),
fProcessLatency(0)
{
fPlugin = new VSTPlugin();
fPlugin->LoadModule(path);
}
BMediaAddOn*
VSTNode::AddOn(int32* id) const
{
if(fAddOn)
*id = 0;
return fAddOn;
}
status_t
VSTNode::HandleMessage(int32 message, const void* data, size_t size)
{
if((BControllable::HandleMessage(message, data, size) != B_OK) &&
(BBufferConsumer::HandleMessage(message, data, size) != B_OK) &&
(BBufferProducer::HandleMessage(message, data, size) != B_OK) &&
(BControllable::HandleMessage(message, data, size) != B_OK) ) {
BMediaNode::HandleMessage(message, data, size);
return B_OK;
}
BMediaNode::HandleBadMessage(message, data, size);
return B_ERROR;
}
void
VSTNode::NodeRegistered()
{
fPreferredFormat.type = B_MEDIA_RAW_AUDIO;
fPreferredFormat.u.raw_audio.buffer_size = BUFF_SIZE;
fPreferredFormat.u.raw_audio = media_raw_audio_format::wildcard;
fPreferredFormat.u.raw_audio.channel_count =
media_raw_audio_format::wildcard.channel_count;
fPreferredFormat.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
fFormat.type = B_MEDIA_RAW_AUDIO;
fFormat.u.raw_audio = media_raw_audio_format::wildcard;
fInputMedia.destination.port = ControlPort();
fInputMedia.destination.id = ID_AUDIO_INPUT;
fInputMedia.node = Node();
fInputMedia.source = media_source::null;
fInputMedia.format = fFormat;
strncpy(fInputMedia.name, "Audio Input", B_MEDIA_NAME_LENGTH);
fOutputMedia.source.port = ControlPort();
fOutputMedia.source.id = ID_AUDIO_OUTPUT;
fOutputMedia.node = Node();
fOutputMedia.destination = media_destination::null;
fOutputMedia.format = fFormat;
strncpy(fOutputMedia.name, "Audio Output", B_MEDIA_NAME_LENGTH);
InitParameterValues();
InitParameterWeb();
SetPriority(B_REAL_TIME_PRIORITY);
Run();
}
status_t
VSTNode::GetParameterValue(int32 id, bigtime_t* lastChangeTime, void* value,
size_t *size)
{
if (*size < sizeof(float) || *size < sizeof(int32))
return B_NO_MEMORY;
type_code v_type = B_FLOAT_TYPE;
BParameter *param;
for(int i = 0; i < fWeb->CountParameters(); i++) {
param = fWeb->ParameterAt(i);
if(param->ID() == id) {
v_type = param->ValueType();
break;
}
}
*size = sizeof(float);
if (id == P_MUTE) {
*(int32*)value = fMute;
*lastChangeTime = fMuteLastChanged;
return B_OK;
} else if (id == P_BYPASS) {
*(int32*)value = fByPass;
*lastChangeTime = fByPassLastChanged;
return B_OK;
} else {
int32 idx = id - P_PARAM;
if (idx >= 0 && idx < fPlugin->ParametersCount()) {
VSTParameter *param = fPlugin->Parameter(idx);
if (v_type == B_FLOAT_TYPE)
*(float*)value = param->Value();
if (v_type == B_INT32_TYPE)
*(int32*)value = (int32)ceil(param->Value());
*lastChangeTime = param->LastChangeTime();
return B_OK;
}
}
return B_ERROR;
}
void
VSTNode::SetParameterValue(int32 id, bigtime_t time, const void* value,
size_t size)
{
int32 idx = id - P_PARAM;
if ((idx >= 0 && idx < fPlugin->ParametersCount()) || id == P_MUTE ||
id == P_BYPASS) {
media_timed_event ev(time, BTimedEventQueue::B_PARAMETER, (void*)value,
BTimedEventQueue::B_NO_CLEANUP, size, id, "VSTParam");
ParameterEventProcessing(&ev);
EventQueue()->AddEvent(ev);
}
}
void
VSTNode::BufferReceived(BBuffer* buffer)
{
if (buffer->Header()->destination != fInputMedia.destination.id) {
buffer->Recycle();
return;
}
if (fOutputMedia.destination == media_destination::null ||
!fOutputMediaEnabled) {
buffer->Recycle();
return;
}
FilterBuffer(buffer);
status_t err = SendBuffer(buffer, fOutputMedia.source,
fOutputMedia.destination);
if (err < B_OK)
buffer->Recycle();
}
status_t
VSTNode::AcceptFormat(const media_destination &dst, media_format* format)
{
if (dst != fInputMedia.destination)
return B_MEDIA_BAD_DESTINATION;
if (format->type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT;
ValidateFormat(
(fFormat.u.raw_audio.format != media_raw_audio_format::wildcard.format) ?
fFormat : fPreferredFormat, *format);
return B_OK;
}
status_t
VSTNode::GetNextInput(int32* cookie, media_input* input)
{
if (*cookie)
return B_BAD_INDEX;
++*cookie;
*input = fInputMedia;
return B_OK;
}
void
VSTNode::DisposeInputCookie(int32 cookie)
{
}
status_t
VSTNode::FormatChanged(const media_source &src, const media_destination &dst,
int32 changeTag, const media_format &format)
{
return B_MEDIA_BAD_FORMAT;
}
void
VSTNode::ProducerDataStatus(const media_destination &dst, int32 status,
bigtime_t when)
{
if (fOutputMedia.destination != media_destination::null)
SendDataStatus(status, fOutputMedia.destination, when);
}
status_t
VSTNode::GetLatencyFor( const media_destination &dst, bigtime_t* latency,
media_node_id* outTimeSource)
{
if (dst != fInputMedia.destination)
return B_MEDIA_BAD_DESTINATION;
*latency = fDownstreamLatency + fProcessLatency;
*outTimeSource = TimeSource()->ID();
return B_OK;
}
status_t
VSTNode::Connected(const media_source& source,
const media_destination& destination, const media_format& format,
media_input* input)
{
if (destination != fInputMedia.destination)
return B_MEDIA_BAD_DESTINATION;
if (fInputMedia.source != media_source::null)
return B_MEDIA_ALREADY_CONNECTED;
fInputMedia.source = source;
fInputMedia.format = format;
*input = fInputMedia;
fFormat = format;
return B_OK;
}
void
VSTNode::Disconnected(const media_source &src, const media_destination &dst)
{
if(fInputMedia.source!=src || dst!=fInputMedia.destination)
return;
fInputMedia.source = media_source::null;
if(fOutputMedia.destination == media_destination::null)
fFormat.u.raw_audio = media_raw_audio_format::wildcard;
fInputMedia.format = fFormat;
}
status_t
VSTNode::FormatSuggestionRequested(media_type type, int32 quality,
media_format* format)
{
if (type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT;
if (fFormat.u.raw_audio.format != media_raw_audio_format::wildcard.format)
*format = fFormat;
else
*format = fPreferredFormat;
return B_OK;
}
status_t
VSTNode::FormatProposal(const media_source &src, media_format* format)
{
if (src != fOutputMedia.source)
return B_MEDIA_BAD_SOURCE;
if (format->type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT;
ValidateFormat(
(fFormat.u.raw_audio.format != media_raw_audio_format::wildcard.format) ?
fFormat : fPreferredFormat, *format);
return B_OK;
}
status_t
VSTNode::FormatChangeRequested(const media_source &src,
const media_destination &dst, media_format* format, int32* _deprecated_)
{
return B_MEDIA_BAD_FORMAT;
}
void
VSTNode::LateNoticeReceived(const media_source &src,
bigtime_t late, bigtime_t when)
{
if (src != fOutputMedia.source || fInputMedia.source == media_source::null)
return;
NotifyLateProducer(fInputMedia.source, late, when);
}
status_t
VSTNode::GetNextOutput(int32 *cookie, media_output* output)
{
if (*cookie)
return B_BAD_INDEX;
++*cookie;
*output = fOutputMedia;
return B_OK;
}
status_t
VSTNode::DisposeOutputCookie(int32 cookie)
{
return B_OK;
}
status_t
VSTNode::SetBufferGroup(const media_source &src, BBufferGroup* group)
{
status_t ret;
int32 changeTag;
if (src != fOutputMedia.source)
return B_MEDIA_BAD_SOURCE;
if (fInputMedia.source == media_source::null)
return B_ERROR;
ret = SetOutputBuffersFor(fInputMedia.source, fInputMedia.destination,
group, 0, &changeTag);
return ret;
}
status_t
VSTNode::PrepareToConnect( const media_source &src, const media_destination &dst,
media_format* format, media_source* out_source, char* name)
{
status_t ret = B_OK;
if (src != fOutputMedia.source)
return B_MEDIA_BAD_SOURCE;
if (format->type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT;
if (fOutputMedia.destination != media_destination::null)
return B_MEDIA_ALREADY_CONNECTED;
ret = ValidateFormat(
(fFormat.u.raw_audio.format != media_raw_audio_format::wildcard.format) ?
fFormat : fPreferredFormat, *format);
if (ret < B_OK)
return ret;
SetOutputFormat(*format);
fOutputMedia.destination = dst;
fOutputMedia.format = *format;
*out_source = fOutputMedia.source;
strncpy(name, fOutputMedia.name, B_MEDIA_NAME_LENGTH);
return B_OK;
}
void
VSTNode::Connect(status_t status, const media_source &src,
const media_destination &dst, const media_format &format, char* name)
{
if (status < B_OK) {
fOutputMedia.destination = media_destination::null;
return;
}
strncpy(name, fOutputMedia.name, B_MEDIA_NAME_LENGTH);
fOutputMedia.destination = dst;
fFormat = format;
media_node_id timeSource;
FindLatencyFor(fOutputMedia.destination, &fDownstreamLatency, &timeSource);
InitFilter();
fProcessLatency = GetFilterLatency();
SetEventLatency(fDownstreamLatency + fProcessLatency);
if (fInputMedia.source != media_source::null) {
SendLatencyChange(fInputMedia.source, fInputMedia.destination,
EventLatency()+SchedulingLatency());
}
bigtime_t duration = 0;
int sample_size = (fFormat.u.raw_audio.format & 0xf)*
fFormat.u.raw_audio.channel_count;
if (fFormat.u.raw_audio.buffer_size > 0 &&
fFormat.u.raw_audio.frame_rate > 0 &&
sample_size > 0) {
duration = (bigtime_t)(((fFormat.u.raw_audio.buffer_size / sample_size) /
fFormat.u.raw_audio.frame_rate) * 1000000.0);
}
SetBufferDuration(duration);
}
void
VSTNode::Disconnect(const media_source &src, const media_destination &dst)
{
if (src != fOutputMedia.source)
return;
if (dst != fOutputMedia.destination)
return;
fOutputMedia.destination = media_destination::null;
if (fInputMedia.source == media_source::null)
fFormat.u.raw_audio = media_raw_audio_format::wildcard;
fOutputMedia.format = fFormat;
}
void
VSTNode::EnableOutput(const media_source &src, bool enabled, int32* _deprecated_)
{
if (src != fOutputMedia.source)
return;
fOutputMediaEnabled = enabled;
}
status_t
VSTNode::GetLatency(bigtime_t* latency)
{
*latency = EventLatency() + SchedulingLatency();
return B_OK;
}
void
VSTNode::LatencyChanged(const media_source &src, const media_destination &dst,
bigtime_t latency, uint32 flags)
{
if (src != fOutputMedia.source || dst != fOutputMedia.destination)
return;
fDownstreamLatency = latency;
SetEventLatency(fDownstreamLatency + fProcessLatency);
if (fInputMedia.source != media_source::null) {
SendLatencyChange(fInputMedia.source,
fInputMedia.destination,EventLatency() + SchedulingLatency());
}
}
bigtime_t
VSTNode::OfflineTime()
{
return 0LL;
}
void
VSTNode::HandleEvent(const media_timed_event *event, bigtime_t late,
bool realTime)
{
if(event->type == BTimedEventQueue::B_PARAMETER)
ParameterEventProcessing(event);
}
void
VSTNode::ParameterEventProcessing(const media_timed_event* event)
{
float value = 0.0;
int32 value32 = 0;
int32 id = event->bigdata;
size_t size = event->data;
bigtime_t now = TimeSource()->Now();
type_code v_type = B_FLOAT_TYPE;
BParameter* web_param;
for(int i = 0; i < fWeb->CountParameters(); i++) {
web_param = fWeb->ParameterAt(i);
if(web_param->ID() == id) {
v_type = web_param->ValueType();
break;
}
}
if (v_type == B_FLOAT_TYPE)
value = *((float*)event->pointer);
if (v_type == B_INT32_TYPE) {
value32 = *((int32*)event->pointer);
value = (float)value32;
}
if (id == P_MUTE) {
fMute = value32;
fMuteLastChanged = now;
BroadcastNewParameterValue(now, id, event->pointer, size);
} else if (id == P_BYPASS) {
fByPass = value32;
fByPassLastChanged = now;
BroadcastNewParameterValue(now, id, event->pointer, size);
} else {
int32 idx = id - P_PARAM;
if (idx >= 0 && idx < fPlugin->ParametersCount()) {
VSTParameter *param = fPlugin->Parameter(idx);
param->SetValue(value);
BroadcastNewParameterValue(now, id, &value, size);
}
}
}
status_t
VSTNode::ValidateFormat(const media_format &preferredFormat,
media_format &proposedFormat)
{
status_t ret = B_OK;
if (proposedFormat.type != B_MEDIA_RAW_AUDIO) {
proposedFormat = preferredFormat;
return B_MEDIA_BAD_FORMAT;
}
const media_raw_audio_format &wild = media_raw_audio_format::wildcard;
media_raw_audio_format &f = proposedFormat.u.raw_audio;
const media_raw_audio_format &pref = preferredFormat.u.raw_audio;
if(pref.frame_rate != wild.frame_rate && f.frame_rate != pref.frame_rate) {
if(f.frame_rate != wild.frame_rate)
ret = B_MEDIA_BAD_FORMAT;
f.frame_rate = pref.frame_rate;
}
if(pref.channel_count != wild.channel_count &&
f.channel_count != pref.channel_count) {
if(f.channel_count != wild.channel_count)
ret = B_MEDIA_BAD_FORMAT;
f.channel_count = pref.channel_count;
}
if(pref.format != wild.format && f.format != pref.format) {
if(f.format != wild.format)
ret = B_MEDIA_BAD_FORMAT;
f.format = pref.format;
}
if(pref.byte_order != wild.byte_order &&
f.byte_order != pref.byte_order) {
if(f.byte_order != wild.byte_order)
ret = B_MEDIA_BAD_FORMAT;
f.byte_order = pref.byte_order;
}
if(pref.buffer_size != wild.buffer_size &&
f.buffer_size != pref.buffer_size) {
if(f.buffer_size != wild.buffer_size)
ret = B_MEDIA_BAD_FORMAT;
f.buffer_size = pref.buffer_size;
}
return ret;
}
void
VSTNode::SetOutputFormat(media_format &format)
{
media_raw_audio_format &f = format.u.raw_audio;
const media_raw_audio_format &w = media_raw_audio_format::wildcard;
if (f.frame_rate == w.frame_rate)
f.frame_rate = 44100.0;
if (f.channel_count == w.channel_count) {
if(fInputMedia.source != media_source::null)
f.channel_count = fInputMedia.format.u.raw_audio.channel_count;
else
f.channel_count = fPlugin->Channels(VST_OUTPUT_CHANNELS);
}
if (f.format == w.format)
f.format = media_raw_audio_format::B_AUDIO_FLOAT;
if (f.byte_order == w.format) {
f.byte_order = (B_HOST_IS_BENDIAN) ?
B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
}
if (f.buffer_size == w.buffer_size)
f.buffer_size = BUFF_SIZE;
}
void
VSTNode::InitParameterValues()
{
fMute = 0;
fByPass = 0;
fMuteLastChanged = 0LL;
fByPassLastChanged = 0LL;
}
void
VSTNode::InitParameterWeb()
{
fWeb = new BParameterWeb();
bool switch_group_needed = false;
for(int i = 0; i < fPlugin->ParametersCount(); i++) {
VSTParameter* param = fPlugin->Parameter(i);
if (param->Type() == VST_PARAM_CHECKBOX ||
param->Type() == VST_PARAM_DROPLIST) {
switch_group_needed = true;
break;
}
}
BParameterGroup* fParamGroup = fWeb->MakeGroup("Parameters");
BParameterGroup* fSwitchesGroup = switch_group_needed ?
fWeb->MakeGroup("Switches") : NULL;
BParameterGroup* fAboutGroup = fWeb->MakeGroup("About");
BParameter* value;
BNullParameter* label;
BParameterGroup* group;
BParameterGroup* fFControlGroup = fParamGroup->MakeGroup("FilterControl");
BParameterGroup* fCheckBoxGroup = switch_group_needed ?
fSwitchesGroup->MakeGroup("CheckBoxes") : NULL;
BParameterGroup* fSelectorsGroup = switch_group_needed ?
fSwitchesGroup->MakeGroup("Selectors") : NULL;
fFControlGroup->MakeDiscreteParameter(P_MUTE,
B_MEDIA_NO_TYPE,"Mute", B_ENABLE);
fFControlGroup->MakeDiscreteParameter(P_BYPASS,
B_MEDIA_NO_TYPE,"ByPass", B_ENABLE);
for(int i = 0; i < fPlugin->ParametersCount(); i++) {
VSTParameter *param = fPlugin->Parameter(i);
switch(param->Type()) {
case VST_PARAM_CHECKBOX:
{
BString str;
str << param->Name() << " (" << param->MinimumValue()
<< "/" << param->MaximumValue() << ")";
value = fCheckBoxGroup->MakeDiscreteParameter(
P_PARAM + param->Index(), B_MEDIA_NO_TYPE,
str.String(), B_ENABLE);
break;
}
case VST_PARAM_DROPLIST:
{
BDiscreteParameter *dvalue =
fSelectorsGroup->MakeDiscreteParameter(P_PARAM + param->Index(),
B_MEDIA_NO_TYPE, param->Name(), B_OUTPUT_MUX);
for(int j = 0; j < param->ListCount(); j++) {
dvalue->AddItem( param->ListItemAt(j)->Index,
param->ListItemAt(j)->Name.String());
}
break;
}
default:
{
BString str;
group = fParamGroup->MakeGroup(param->Name());
label = group->MakeNullParameter(P_LABEL + param->Index(),
B_MEDIA_NO_TYPE, param->Name(), B_GENERIC);
str.SetTo(param->MaximumValue());
str << " " << param->Unit();
group->MakeNullParameter(P_LABEL2 + param->Index(),
B_MEDIA_NO_TYPE, str.String(), B_GENERIC);
value = group->MakeContinuousParameter(P_PARAM + param->Index(),
B_MEDIA_NO_TYPE, "", B_GAIN, "", 0.0, 1.0, 0.01);
label->AddOutput(value);
value->AddInput(label);
str.SetTo(param->MinimumValue());
str << " " << param->Unit();
group->MakeNullParameter(P_LABEL3 + param->Index(),
B_MEDIA_NO_TYPE, str.String(), B_GENERIC);
break;
}
}
}
BString str("About plugin");
label = fAboutGroup->MakeNullParameter(P_ABOUT + 0,
B_MEDIA_NO_TYPE, str.String(), B_GENERIC);
str.SetTo("Effect name: ");
if (strlen(fPlugin->EffectName()) != 0)
str.Append(fPlugin->EffectName());
else
str.Append("not specified");
label = fAboutGroup->MakeNullParameter(P_ABOUT + 1,
B_MEDIA_NO_TYPE, str.String(), B_GENERIC);
str.SetTo("Vendor: ");
if (strlen(fPlugin->Vendor()) != 0)
str.Append(fPlugin->Vendor());
else
str.Append("not specified");
label = fAboutGroup->MakeNullParameter(P_ABOUT + 2,
B_MEDIA_NO_TYPE, str.String(), B_GENERIC);
str.SetTo("Product: ");
if (strlen(fPlugin->Product()) != 0)
str.Append(fPlugin->Product());
else
str.Append("not specified");
label = fAboutGroup->MakeNullParameter(P_ABOUT + 3,
B_MEDIA_NO_TYPE, str.String(), B_GENERIC);
str.SetTo("Input Channels: ");
str<<fPlugin->Channels(VST_INPUT_CHANNELS);
label = fAboutGroup->MakeNullParameter(P_ABOUT + 4,
B_MEDIA_NO_TYPE, str.String(), B_GENERIC);
str.SetTo("Output Channels: ");
str<<fPlugin->Channels(VST_OUTPUT_CHANNELS);
label = fAboutGroup->MakeNullParameter(P_ABOUT + 5,
B_MEDIA_NO_TYPE, str.String(), B_GENERIC);
SetParameterWeb(fWeb);
}
void
VSTNode::InitFilter()
{
fBlockSize = fFormat.u.raw_audio.buffer_size /
(fFormat.u.raw_audio.channel_count * sizeof(float));
fPlugin->SetBlockSize(fBlockSize);
fPlugin->SetSampleRate(fFormat.u.raw_audio.frame_rate);
}
bigtime_t
VSTNode::GetFilterLatency()
{
if (fOutputMedia.destination == media_destination::null)
return 0LL;
BBufferGroup* temp_group =
new BBufferGroup(fOutputMedia.format.u.raw_audio.buffer_size, 1);
BBuffer *buffer =
temp_group->RequestBuffer(fOutputMedia.format.u.raw_audio.buffer_size);
buffer->Header()->type = B_MEDIA_RAW_AUDIO;
buffer->Header()->size_used = fOutputMedia.format.u.raw_audio.buffer_size;
bigtime_t begin = system_time();
FilterBuffer(buffer);
bigtime_t latency = system_time()-begin;
InitFilter();
buffer->Recycle();
delete temp_group;
return latency;
}
void
VSTNode::FilterBuffer(BBuffer* buffer)
{
uint32 m_frameSize = (fFormat.u.raw_audio.format & 0x0f)*
fFormat.u.raw_audio.channel_count;
uint32 samples = buffer->Header()->size_used / m_frameSize;
uint32 channels = fFormat.u.raw_audio.channel_count;
if (fMute != 0) {
memset(buffer->Data(), 0, buffer->Header()->size_used);
} else {
if (fByPass == 0) {
fPlugin->Process((float*)buffer->Data(), samples, channels);
}
}
}
