#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 "EqualizerNode.h"
EqualizerNode::~EqualizerNode()
{
Quit();
}
EqualizerNode::EqualizerNode(BMediaAddOn* addon)
:
BMediaNode("10 Band Equalizer"),
BBufferConsumer(B_MEDIA_RAW_AUDIO),
BBufferProducer(B_MEDIA_RAW_AUDIO),
BControllable(),
BMediaEventLooper(),
fAddOn(addon),
fProcessLatency(0),
fDownstreamLatency(0),
fOutputMediaEnabled(true)
{
}
BMediaAddOn*
EqualizerNode::AddOn(int32* id) const
{
if (fAddOn)
*id = 0;
return fAddOn;
}
status_t
EqualizerNode::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
EqualizerNode::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
EqualizerNode::GetParameterValue(int32 id, bigtime_t* lastChangeTime,
void* value, size_t* size)
{
if (*size < sizeof(float))
return B_NO_MEMORY;
if (id == P_MUTE) {
*(int32*)value = fMute;
*lastChangeTime = fMuteLastChanged;
*size = sizeof(int32);
} else if (id == P_BYPASS) {
*(int32*)value = fByPass;
*lastChangeTime = fByPassLastChanged;
*size = sizeof(int32);
} else if (id == P_PREAMP) {
*(float*)value = (float)fEqualizer.PreAmp();
*lastChangeTime = fPreAmpLastChanged;
*size = sizeof(float);
} else if (id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount()) {
int band = id - P_BANDS;
*(float*)value = (float)fEqualizer.Band(band);
*lastChangeTime = fBandsLastChanged[band];
*size = sizeof(float);
} else
return B_ERROR;
return B_OK;
}
void
EqualizerNode::SetParameterValue(int32 id, bigtime_t time, const void* value,
size_t size)
{
if (id == P_PREAMP || id == P_BYPASS || id == P_MUTE
|| (id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount())) {
media_timed_event ev(time, BTimedEventQueue::B_PARAMETER, (void*)value,
BTimedEventQueue::B_NO_CLEANUP, size, id, (char*)"EQ");
ParameterEventProcessing(&ev);
EventQueue()->AddEvent(ev);
}
}
void
EqualizerNode::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
EqualizerNode::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
EqualizerNode::GetNextInput(int32* cookie, media_input* input)
{
if (*cookie)
return B_BAD_INDEX;
++*cookie;
*input = fInputMedia;
return B_OK;
}
void
EqualizerNode::DisposeInputCookie(int32 cookie)
{
}
status_t
EqualizerNode::FormatChanged(const media_source &src,
const media_destination &dst, int32 changeTag, const media_format &format)
{
return B_MEDIA_BAD_FORMAT;
}
void
EqualizerNode::ProducerDataStatus(const media_destination &dst, int32 status,
bigtime_t when)
{
if (fOutputMedia.destination != media_destination::null)
SendDataStatus(status, fOutputMedia.destination, when);
}
status_t
EqualizerNode::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
EqualizerNode::Connected(const media_source& source,
const media_destination& destination, const media_format& format,
media_input* poInput)
{
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;
*poInput = fInputMedia;
fFormat = format;
return B_OK;
}
void
EqualizerNode::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
EqualizerNode::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
EqualizerNode::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
EqualizerNode::FormatChangeRequested(const media_source &src,
const media_destination &dst, media_format* format, int32* _deprecated_)
{
return B_MEDIA_BAD_FORMAT;
}
void
EqualizerNode::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
EqualizerNode::GetNextOutput(int32* cookie, media_output* output)
{
if (*cookie)
return B_BAD_INDEX;
++*cookie;
*output = fOutputMedia;
return B_OK;
}
status_t
EqualizerNode::DisposeOutputCookie(int32 cookie)
{
return B_OK;
}
status_t
EqualizerNode::SetBufferGroup(const media_source &src, BBufferGroup* group)
{
int32 changeTag;
status_t ret = B_OK;
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
EqualizerNode::PrepareToConnect(const media_source &src,
const media_destination &dst, media_format* format, media_source* outSource,
char* outName)
{
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;
status_t err = ValidateFormat((fFormat.u.raw_audio.format
!= media_raw_audio_format::wildcard.format) ? fFormat
: fPreferredFormat, *format);
if (err < B_OK)
return err;
SetOutputFormat(*format);
fOutputMedia.destination = dst;
fOutputMedia.format = *format;
*outSource = fOutputMedia.source;
strncpy(outName, fOutputMedia.name, B_MEDIA_NAME_LENGTH);
return B_OK;
}
void
EqualizerNode::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
EqualizerNode::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
EqualizerNode::EnableOutput(const media_source &src, bool enabled,
int32* _deprecated_)
{
if (src != fOutputMedia.source)
return;
fOutputMediaEnabled = enabled;
}
status_t
EqualizerNode::GetLatency(bigtime_t* latency)
{
*latency = EventLatency() + SchedulingLatency();
return B_OK;
}
void
EqualizerNode::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
EqualizerNode::OfflineTime()
{
return 0LL;
}
void
EqualizerNode::HandleEvent(const media_timed_event* event, bigtime_t late,
bool realTime)
{
if (event->type == BTimedEventQueue::B_PARAMETER)
ParameterEventProcessing(event);
}
void
EqualizerNode::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);
else 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 if (id == P_PREAMP) {
if (value != fEqualizer.PreAmp()) {
fEqualizer.SetPreAmp(value);
fPreAmpLastChanged = now;
BroadcastNewParameterValue(now, id, &value, size);
}
} else if (id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount()) {
int band = id - P_BANDS;
if (value != fEqualizer.Band(band)) {
fEqualizer.SetBand(band, value);
fBandsLastChanged[band] = now;
BroadcastNewParameterValue(now, id, &value, size);
}
}
}
status_t
EqualizerNode::ValidateFormat(const media_format &preferred_format,
media_format &proposed_format)
{
status_t ret = B_OK;
if (proposed_format.type != B_MEDIA_RAW_AUDIO) {
proposed_format = preferred_format;
return B_MEDIA_BAD_FORMAT;
}
const media_raw_audio_format &wild = media_raw_audio_format::wildcard;
media_raw_audio_format &f = proposed_format.u.raw_audio;
const media_raw_audio_format &pref = preferred_format.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
EqualizerNode::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 = 2;
}
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
EqualizerNode::InitParameterValues()
{
fMute = 0;
fByPass = 0;
fMuteLastChanged = 0LL;
fByPassLastChanged = 0LL;
fPreAmpLastChanged = 0LL;
for (int i = 0; i < EQ_BANDS; i++)
fBandsLastChanged[i] = 0LL;
fEqualizer.CleanUp();
}
void
EqualizerNode::InitParameterWeb(void)
{
fWeb = new BParameterWeb();
BParameterGroup* fParamGroup = fWeb->MakeGroup("EqualizerNode Parameters");
BParameterGroup* fFControlGroup = fParamGroup->MakeGroup("FilterControl");
fFControlGroup->MakeDiscreteParameter(P_MUTE,B_MEDIA_NO_TYPE,"Mute",
B_ENABLE);
fFControlGroup->MakeDiscreteParameter(P_BYPASS,B_MEDIA_NO_TYPE,"ByPass",
B_ENABLE);
BNullParameter* label;
BParameterGroup* group;
BContinuousParameter* value;
group = fParamGroup->MakeGroup("Pre Amp");
label = group->MakeNullParameter(P_PREAMP_LABEL, B_MEDIA_NO_TYPE, "Pre Amp",
B_GENERIC);
value = group->MakeContinuousParameter(P_PREAMP, B_MEDIA_NO_TYPE, "",
B_GAIN, "dB", -8.0, 8.0, 0.1);
label->AddOutput(value);
value->AddInput(label);
for (int i = 0; i < fEqualizer.BandCount(); i++) {
char freq[32];
sprintf(freq,"%gHz",fEqualizer.BandFrequency(i));
group = fParamGroup->MakeGroup(freq);
label = group->MakeNullParameter(P_BAND_LABELS + i, B_MEDIA_NO_TYPE,
freq, B_GENERIC);
value = group->MakeContinuousParameter(P_BANDS + i, B_MEDIA_NO_TYPE,
"", B_GAIN, "dB", -16.0, 16.0, 0.1);
label->AddOutput(value);
value->AddInput(label);
}
SetParameterWeb(fWeb);
}
void
EqualizerNode::InitFilter(void)
{
fEqualizer.SetFormat(fFormat.u.raw_audio.channel_count,
fFormat.u.raw_audio.frame_rate);
}
bigtime_t
EqualizerNode::GetFilterLatency(void)
{
if (fOutputMedia.destination == media_destination::null)
return 0LL;
BBufferGroup* test_group =
new BBufferGroup(fOutputMedia.format.u.raw_audio.buffer_size, 1);
BBuffer* buffer =
test_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;
buffer->Recycle();
delete test_group;
InitFilter();
return latency;
}
void
EqualizerNode::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)
fEqualizer.ProcessBuffer((float*)buffer->Data(), samples * channels);
}
