i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Coding style fixes, should have no functional changes.

Browse Source
This commit is contained in:
Philippe Saint-Pierre
2012-10-13 16:04:18 -04:00
parent 9815f07dce
commit 56bc38cef0
1 changed files with 233 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/media/media-add-ons/equalizer/EqualizerNode.cpp
+233 -209
View File
@@ -1,5 +1,6 @@
/* /*
* Copyright 2012, Gerasim Troeglazov (3dEyes**), [email protected]. All rights reserved. * Copyright 2012, Gerasim Troeglazov (3dEyes**), [email protected].
* All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
*/ */
@@ -16,11 +17,14 @@
#include "EqualizerNode.h" #include "EqualizerNode.h"
//EqualizerNode //EqualizerNode
EqualizerNode::~EqualizerNode() { EqualizerNode::~EqualizerNode()
{
Quit(); Quit();
} }
EqualizerNode::EqualizerNode(BMediaAddOn* addon) :
EqualizerNode::EqualizerNode(BMediaAddOn* addon)
:
BMediaNode("10 Band Equalizer"), BMediaNode("10 Band Equalizer"),
BBufferConsumer(B_MEDIA_RAW_AUDIO), BBufferConsumer(B_MEDIA_RAW_AUDIO),
BBufferProducer(B_MEDIA_RAW_AUDIO), BBufferProducer(B_MEDIA_RAW_AUDIO),
@@ -33,30 +37,32 @@ EqualizerNode::EqualizerNode(BMediaAddOn* addon) :
{ {
} }
//BMediaNode //BMediaNode
BMediaAddOn* BMediaAddOn*
EqualizerNode::AddOn(int32 *id) const EqualizerNode::AddOn(int32* id) const
{ {
if(fAddOn) if (fAddOn)
*id = 0; *id = 0;
return fAddOn; return fAddOn;
} }
status_t status_t
EqualizerNode::HandleMessage(int32 message, const void *data, size_t size) EqualizerNode::HandleMessage(int32 message, const void *data, size_t size)
{ {
if((BControllable::HandleMessage(message, data, size)!=B_OK) && if ((BControllable::HandleMessage(message, data, size) != B_OK) &&
(BBufferConsumer::HandleMessage(message, data, size) != B_OK) && (BBufferConsumer::HandleMessage(message, data, size) != B_OK) &&
(BBufferProducer::HandleMessage(message, data, size) != B_OK) && (BBufferProducer::HandleMessage(message, data, size) != B_OK) &&
(BControllable::HandleMessage(message, data, size) != B_OK) ) { (BControllable::HandleMessage(message, data, size) != B_OK)) {
BMediaNode::HandleMessage(message, data, size); BMediaNode::HandleMessage(message, data, size);
return B_OK; return B_OK;
} else { }
BMediaNode::HandleBadMessage(message, data, size); BMediaNode::HandleBadMessage(message, data, size);
return B_ERROR; return B_ERROR;
}
} }
void void
EqualizerNode::NodeRegistered() EqualizerNode::NodeRegistered()
{ {
@@ -66,7 +72,8 @@ EqualizerNode::NodeRegistered()
fPreferredFormat.type = B_MEDIA_RAW_AUDIO; fPreferredFormat.type = B_MEDIA_RAW_AUDIO;
fPreferredFormat.u.raw_audio.buffer_size = BUFF_SIZE; fPreferredFormat.u.raw_audio.buffer_size = BUFF_SIZE;
fPreferredFormat.u.raw_audio = media_raw_audio_format::wildcard; 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.channel_count =
media_raw_audio_format::wildcard.channel_count;
fPreferredFormat.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT; fPreferredFormat.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
fFormat.type = B_MEDIA_RAW_AUDIO; fFormat.type = B_MEDIA_RAW_AUDIO;
@@ -90,146 +97,153 @@ EqualizerNode::NodeRegistered()
InitParameterWeb(); InitParameterWeb();
} }
//BControllable //BControllable
status_t status_t
EqualizerNode::GetParameterValue(int32 id, bigtime_t *lastChangeTime, void *value, size_t *size) EqualizerNode::GetParameterValue(int32 id, bigtime_t* lastChangeTime,
void* value, size_t* size)
{ {
if(*size < sizeof(float)) { if (*size < sizeof(float))
return B_NO_MEMORY; return B_NO_MEMORY;
}
if(id == P_MUTE) { if (id == P_MUTE) {
*(int32*)value = fMute; *(int32*)value = fMute;
*lastChangeTime = fMuteLastChanged; *lastChangeTime = fMuteLastChanged;
*size = sizeof(int32); *size = sizeof(int32);
return B_OK; } else if (id == P_BYPASS) {
} else if(id == P_BYPASS) {
*(int32*)value = fByPass; *(int32*)value = fByPass;
*lastChangeTime = fByPassLastChanged; *lastChangeTime = fByPassLastChanged;
*size = sizeof(int32); *size = sizeof(int32);
return B_OK; } else if (id == P_PREAMP) {
} else if(id == P_PREAMP) {
*(float*)value = (float)fEqualizer.PreAmp(); *(float*)value = (float)fEqualizer.PreAmp();
*lastChangeTime = fPreAmpLastChanged; *lastChangeTime = fPreAmpLastChanged;
*size = sizeof(float); *size = sizeof(float);
return B_OK; } else if (id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount()) {
} else if(id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount()) {
int band = id - P_BANDS; int band = id - P_BANDS;
*(float*)value = (float)fEqualizer.Band(band); *(float*)value = (float)fEqualizer.Band(band);
*lastChangeTime = fBandsLastChanged[band]; *lastChangeTime = fBandsLastChanged[band];
*size = sizeof(float); *size = sizeof(float);
return B_OK; } else
} return B_ERROR;
return B_OK;
return B_ERROR;
} }
void void
EqualizerNode::SetParameterValue(int32 id, bigtime_t time, const void *value, size_t size) EqualizerNode::SetParameterValue(int32 id, bigtime_t time, const void* value,
size_t size)
{ {
if(id == P_PREAMP || id == P_BYPASS || id == P_MUTE || if (id == P_PREAMP || id == P_BYPASS || id == P_MUTE
(id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount())) { || (id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount())) {
media_timed_event ev(time, BTimedEventQueue::B_PARAMETER, (void*)value, media_timed_event ev(time, BTimedEventQueue::B_PARAMETER, (void*)value,
BTimedEventQueue::B_NO_CLEANUP, size, id, "EQ"); BTimedEventQueue::B_NO_CLEANUP, size, id, "EQ");
ParameterEventProcessing(&ev); //dirty hack for parameter processing (mediakit bug????) ParameterEventProcessing(&ev);
//dirty hack for parameter processing (mediakit bug????)
EventQueue()->AddEvent(ev); EventQueue()->AddEvent(ev);
} }
} }
//BBufferConsumer //BBufferConsumer
void void
EqualizerNode::BufferReceived(BBuffer *buffer) EqualizerNode::BufferReceived(BBuffer* buffer)
{ {
if(buffer->Header()->destination != fInputMedia.destination.id) { if (buffer->Header()->destination != fInputMedia.destination.id) {
buffer->Recycle(); buffer->Recycle();
return; return;
} }
if(fOutputMedia.destination == media_destination::null || !fOutputMediaEnabled) { if (fOutputMedia.destination == media_destination::null
|| !fOutputMediaEnabled) {
buffer->Recycle(); buffer->Recycle();
return; return;
} }
FilterBuffer(buffer); FilterBuffer(buffer);
status_t err = SendBuffer(buffer, fOutputMedia.source, fOutputMedia.destination); status_t err = SendBuffer(buffer, fOutputMedia.source,
if (err < B_OK) { fOutputMedia.destination);
if (err < B_OK)
buffer->Recycle(); buffer->Recycle();
}
} }
status_t status_t
EqualizerNode::AcceptFormat(const media_destination &dst, media_format *format) EqualizerNode::AcceptFormat(const media_destination &dst, media_format* format)
{ {
if(dst != fInputMedia.destination) { if (dst != fInputMedia.destination)
return B_MEDIA_BAD_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) ? if (format->type != B_MEDIA_RAW_AUDIO)
fFormat : fPreferredFormat, *format); return B_MEDIA_BAD_FORMAT;
ValidateFormat((fFormat.u.raw_audio.format
!= media_raw_audio_format::wildcard.format) ?
fFormat : fPreferredFormat, *format);
return B_OK; return B_OK;
} }
status_t status_t
EqualizerNode::GetNextInput(int32* cookie, media_input* input) EqualizerNode::GetNextInput(int32* cookie, media_input* input)
{ {
if(*cookie) { if (*cookie)
return B_BAD_INDEX; return B_BAD_INDEX;
}
++*cookie; ++*cookie;
*input = fInputMedia; *input = fInputMedia;
return B_OK; return B_OK;
} }
void void
EqualizerNode::DisposeInputCookie(int32 cookie) EqualizerNode::DisposeInputCookie(int32 cookie)
{ {
} }
status_t status_t
EqualizerNode::FormatChanged(const media_source &src, const media_destination &dst, EqualizerNode::FormatChanged(const media_source &src,
int32 changeTag, const media_format &format) const media_destination &dst, int32 changeTag, const media_format &format)
{ {
return B_MEDIA_BAD_FORMAT; return B_MEDIA_BAD_FORMAT;
} }
void void
EqualizerNode::ProducerDataStatus(const media_destination &dst, int32 status, bigtime_t when) EqualizerNode::ProducerDataStatus(const media_destination &dst, int32 status,
bigtime_t when)
{ {
if(fOutputMedia.destination != media_destination::null) { if (fOutputMedia.destination != media_destination::null)
SendDataStatus(status, fOutputMedia.destination, when); SendDataStatus(status, fOutputMedia.destination, when);
}
} }
status_t status_t
EqualizerNode::GetLatencyFor( const media_destination &dst, bigtime_t *latency, EqualizerNode::GetLatencyFor(const media_destination &dst, bigtime_t* latency,
media_node_id* outTimeSource) media_node_id* outTimeSource)
{ {
if(dst != fInputMedia.destination) { if (dst != fInputMedia.destination)
return B_MEDIA_BAD_DESTINATION; return B_MEDIA_BAD_DESTINATION;
}
*latency = fDownstreamLatency + fProcessLatency; *latency = fDownstreamLatency + fProcessLatency;
*outTimeSource = TimeSource()->ID(); *outTimeSource = TimeSource()->ID();
return B_OK; return B_OK;
} }
status_t status_t
EqualizerNode::Connected(const media_source& source, EqualizerNode::Connected(const media_source& source,
const media_destination& destination, const media_format& format, const media_destination& destination, const media_format& format,
media_input* poInput) media_input* poInput)
{ {
if(destination != fInputMedia.destination) { if (destination != fInputMedia.destination)
return B_MEDIA_BAD_DESTINATION; return B_MEDIA_BAD_DESTINATION;
}
if(fInputMedia.source != media_source::null) { if (fInputMedia.source != media_source::null)
return B_MEDIA_ALREADY_CONNECTED; return B_MEDIA_ALREADY_CONNECTED;
}
fInputMedia.source = source; fInputMedia.source = source;
fInputMedia.format = format; fInputMedia.format = format;
@@ -239,125 +253,132 @@ EqualizerNode::Connected(const media_source& source,
return B_OK; return B_OK;
} }
void void
EqualizerNode::Disconnected(const media_source &src, const media_destination &dst) EqualizerNode::Disconnected(const media_source &src,
const media_destination &dst)
{ {
if(fInputMedia.source != src || dst != fInputMedia.destination) { if (fInputMedia.source != src || dst != fInputMedia.destination)
return; return;
}
fInputMedia.source = media_source::null; fInputMedia.source = media_source::null;
if(fOutputMedia.destination == media_destination::null) { if (fOutputMedia.destination == media_destination::null)
fFormat.u.raw_audio = media_raw_audio_format::wildcard; fFormat.u.raw_audio = media_raw_audio_format::wildcard;
}
fInputMedia.format = fFormat; fInputMedia.format = fFormat;
} }
//BBufferProducer //BBufferProducer
status_t status_t
EqualizerNode::FormatSuggestionRequested(media_type type, int32 quality, media_format *format) EqualizerNode::FormatSuggestionRequested(media_type type, int32 quality,
media_format* format)
{ {
if(type != B_MEDIA_RAW_AUDIO) { if (type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT; return B_MEDIA_BAD_FORMAT;
}
if(fFormat.u.raw_audio.format != media_raw_audio_format::wildcard.format) { if (fFormat.u.raw_audio.format != media_raw_audio_format::wildcard.format)
*format = fFormat; *format = fFormat;
} else { else
*format = fPreferredFormat; *format = fPreferredFormat;
}
return B_OK; return B_OK;
} }
status_t status_t
EqualizerNode::FormatProposal(const media_source &src, media_format* format) EqualizerNode::FormatProposal(const media_source &src, media_format* format)
{ {
if(src != fOutputMedia.source) { if (src != fOutputMedia.source)
return B_MEDIA_BAD_SOURCE; return B_MEDIA_BAD_SOURCE;
}
if(format->type != B_MEDIA_RAW_AUDIO) { if (format->type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT; return B_MEDIA_BAD_FORMAT;
}
ValidateFormat((fFormat.u.raw_audio.format != media_raw_audio_format::wildcard.format) ? ValidateFormat((fFormat.u.raw_audio.format
fFormat:fPreferredFormat,*format); != media_raw_audio_format::wildcard.format) ?
fFormat:fPreferredFormat, *format);
return B_OK; return B_OK;
} }
status_t status_t
EqualizerNode::FormatChangeRequested(const media_source &src, const media_destination &dst, EqualizerNode::FormatChangeRequested(const media_source &src,
media_format* format, int32* _deprecated_) const media_destination &dst, media_format* format, int32* _deprecated_)
{ {
return B_MEDIA_BAD_FORMAT; return B_MEDIA_BAD_FORMAT;
} }
void void
EqualizerNode::LateNoticeReceived(const media_source &src, bigtime_t late, bigtime_t when) EqualizerNode::LateNoticeReceived(const media_source &src, bigtime_t late,
bigtime_t when)
{ {
if(src != fOutputMedia.source || fInputMedia.source == media_source::null) { if (src != fOutputMedia.source || fInputMedia.source == media_source::null)
return; return;
}
NotifyLateProducer(fInputMedia.source, late, when); NotifyLateProducer(fInputMedia.source, late, when);
} }
status_t status_t
EqualizerNode::GetNextOutput(int32 *cookie, media_output* output) EqualizerNode::GetNextOutput(int32* cookie, media_output* output)
{ {
if(*cookie) { if (*cookie)
return B_BAD_INDEX; return B_BAD_INDEX;
}
++*cookie; ++*cookie;
*output = fOutputMedia; *output = fOutputMedia;
return B_OK; return B_OK;
} }
status_t status_t
EqualizerNode::DisposeOutputCookie(int32 cookie) EqualizerNode::DisposeOutputCookie(int32 cookie)
{ {
return B_OK; return B_OK;
} }
status_t status_t
EqualizerNode::SetBufferGroup(const media_source &src, BBufferGroup *group) EqualizerNode::SetBufferGroup(const media_source &src, BBufferGroup* group)
{ {
int32 changeTag; int32 changeTag;
status_t ret = B_OK; status_t ret = B_OK;
if(src != fOutputMedia.source) { if (src != fOutputMedia.source)
return B_MEDIA_BAD_SOURCE; return B_MEDIA_BAD_SOURCE;
}
if(fInputMedia.source == media_source::null) {
return B_ERROR;
}
ret = SetOutputBuffersFor(fInputMedia.source, fInputMedia.destination, group, 0, &changeTag); if (fInputMedia.source == media_source::null)
return B_ERROR;
ret = SetOutputBuffersFor(fInputMedia.source, fInputMedia.destination,
group, 0, &changeTag);
return ret; return ret;
} }
status_t status_t
EqualizerNode::PrepareToConnect( const media_source &src, const media_destination &dst, EqualizerNode::PrepareToConnect(const media_source &src,
media_format* format, media_source* outSource, char* outName) const media_destination &dst, media_format* format, media_source* outSource,
char* outName)
{ {
if(src != fOutputMedia.source) { if (src != fOutputMedia.source)
return B_MEDIA_BAD_SOURCE; return B_MEDIA_BAD_SOURCE;
}
if(format->type != B_MEDIA_RAW_AUDIO) { if (format->type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT; return B_MEDIA_BAD_FORMAT;
}
if(fOutputMedia.destination != media_destination::null) { if (fOutputMedia.destination != media_destination::null)
return B_MEDIA_ALREADY_CONNECTED; return B_MEDIA_ALREADY_CONNECTED;
}
status_t err = ValidateFormat((fFormat.u.raw_audio.format != media_raw_audio_format::wildcard.format) ? status_t err = ValidateFormat((fFormat.u.raw_audio.format
fFormat : fPreferredFormat, *format); != media_raw_audio_format::wildcard.format) ? fFormat
: fPreferredFormat, *format);
if(err < B_OK) { if (err < B_OK)
return err; return err;
}
SetOutputFormat(*format); SetOutputFormat(*format);
@@ -370,12 +391,13 @@ EqualizerNode::PrepareToConnect( const media_source &src, const media_destinatio
return B_OK; return B_OK;
} }
void void
EqualizerNode::Connect(status_t status, const media_source &src, const media_destination &dst, EqualizerNode::Connect(status_t status, const media_source &src,
const media_format &format, char *outName) const media_destination &dst, const media_format &format, char* outName)
{ {
status_t err; status_t err;
if(status < B_OK) { if (status < B_OK) {
fOutputMedia.destination = media_destination::null; fOutputMedia.destination = media_destination::null;
return; return;
} }
@@ -385,86 +407,87 @@ EqualizerNode::Connect(status_t status, const media_source &src, const media_des
fFormat = format; fFormat = format;
media_node_id timeSource; media_node_id timeSource;
err = FindLatencyFor(fOutputMedia.destination, &fDownstreamLatency, &timeSource); err = FindLatencyFor(fOutputMedia.destination, &fDownstreamLatency,
&timeSource);
InitFilter(); InitFilter();
fProcessLatency = GetFilterLatency(); fProcessLatency = GetFilterLatency();
SetEventLatency(fDownstreamLatency + fProcessLatency); SetEventLatency(fDownstreamLatency + fProcessLatency);
if(fInputMedia.source != media_source::null) { if (fInputMedia.source != media_source::null) {
SendLatencyChange(fInputMedia.source, fInputMedia.destination, SendLatencyChange(fInputMedia.source, fInputMedia.destination,
EventLatency() + SchedulingLatency()); EventLatency() + SchedulingLatency());
} }
bigtime_t duration = 0; bigtime_t duration = 0;
int sample_size = (fFormat.u.raw_audio.format & 0xf) * int sample_size = (fFormat.u.raw_audio.format & 0xf)
fFormat.u.raw_audio.channel_count; * fFormat.u.raw_audio.channel_count;
if (fFormat.u.raw_audio.buffer_size > 0 && if (fFormat.u.raw_audio.buffer_size > 0
fFormat.u.raw_audio.frame_rate > 0 && && fFormat.u.raw_audio.frame_rate > 0 && sample_size > 0) {
sample_size > 0) { duration = (bigtime_t)(((fFormat.u.raw_audio.buffer_size / sample_size)
duration = (bigtime_t)(((fFormat.u.raw_audio.buffer_size / sample_size) / / fFormat.u.raw_audio.frame_rate) * 1000000.0);
fFormat.u.raw_audio.frame_rate) * 1000000.0);
} }
SetBufferDuration(duration); SetBufferDuration(duration);
} }
void void
EqualizerNode::Disconnect(const media_source &src, const media_destination &dst) EqualizerNode::Disconnect(const media_source &src, const media_destination &dst)
{ {
if(src != fOutputMedia.source) { if (src != fOutputMedia.source)
return; return;
}
if(dst != fOutputMedia.destination) { if (dst != fOutputMedia.destination)
return; return;
}
fOutputMedia.destination = media_destination::null; fOutputMedia.destination = media_destination::null;
if(fInputMedia.source == media_source::null) { if (fInputMedia.source == media_source::null)
fFormat.u.raw_audio = media_raw_audio_format::wildcard; fFormat.u.raw_audio = media_raw_audio_format::wildcard;
}
fOutputMedia.format = fFormat; fOutputMedia.format = fFormat;
} }
void void
EqualizerNode::EnableOutput(const media_source &src, bool enabled, int32* _deprecated_) EqualizerNode::EnableOutput(const media_source &src, bool enabled,
int32* _deprecated_)
{ {
if(src != fOutputMedia.source) { if (src != fOutputMedia.source)
return; return;
}
fOutputMediaEnabled = enabled; fOutputMediaEnabled = enabled;
} }
status_t status_t
EqualizerNode::GetLatency(bigtime_t *latency) EqualizerNode::GetLatency(bigtime_t* latency)
{ {
*latency = EventLatency() + SchedulingLatency(); *latency = EventLatency() + SchedulingLatency();
return B_OK; return B_OK;
} }
void void
EqualizerNode::LatencyChanged(const media_source &src, const media_destination &dst, EqualizerNode::LatencyChanged(const media_source &src,
bigtime_t latency, uint32 flags) const media_destination &dst, bigtime_t latency, uint32 flags)
{ {
if(src != fOutputMedia.source || dst != fOutputMedia.destination) { if (src != fOutputMedia.source || dst != fOutputMedia.destination)
return; return;
}
fDownstreamLatency = latency; fDownstreamLatency = latency;
SetEventLatency(fDownstreamLatency + fProcessLatency); SetEventLatency(fDownstreamLatency + fProcessLatency);
if(fInputMedia.source != media_source::null) { if (fInputMedia.source != media_source::null) {
SendLatencyChange(fInputMedia.source, SendLatencyChange(fInputMedia.source,
fInputMedia.destination,EventLatency() + SchedulingLatency()); fInputMedia.destination,EventLatency() + SchedulingLatency());
} }
} }
//BMediaEventLooper //BMediaEventLooper
bigtime_t bigtime_t
EqualizerNode::OfflineTime() EqualizerNode::OfflineTime()
@@ -472,17 +495,17 @@ EqualizerNode::OfflineTime()
return 0LL; return 0LL;
} }
//EqualizerNode //EqualizerNode
void void
EqualizerNode::HandleEvent(const media_timed_event *event, bigtime_t late, bool realTime) EqualizerNode::HandleEvent(const media_timed_event* event, bigtime_t late,
bool realTime)
{ {
if(event->type == BTimedEventQueue::B_PARAMETER) { if (event->type == BTimedEventQueue::B_PARAMETER)
ParameterEventProcessing(event); ParameterEventProcessing(event);
}
} }
void void
EqualizerNode::ParameterEventProcessing(const media_timed_event* event) EqualizerNode::ParameterEventProcessing(const media_timed_event* event)
{ {
@@ -495,40 +518,40 @@ EqualizerNode::ParameterEventProcessing(const media_timed_event* event)
type_code v_type = B_FLOAT_TYPE; type_code v_type = B_FLOAT_TYPE;
BParameter *web_param; BParameter* web_param;
for(int i=0; i<fWeb->CountParameters(); i++) { for (int i = 0; i < fWeb->CountParameters(); i++) {
web_param = fWeb->ParameterAt(i); web_param = fWeb->ParameterAt(i);
if(web_param->ID() == id) { if (web_param->ID() == id) {
v_type=web_param->ValueType(); v_type=web_param->ValueType();
break; break;
} }
} }
if(v_type == B_FLOAT_TYPE) if (v_type == B_FLOAT_TYPE)
value = *((float*)event->pointer); value = *((float*)event->pointer);
if(v_type == B_INT32_TYPE) { else if (v_type == B_INT32_TYPE) {
value32 = *((int32*)event->pointer); value32 = *((int32*)event->pointer);
value = (float)value32; value = (float)value32;
} }
if(id == P_MUTE) { if (id == P_MUTE) {
fMute = value32; fMute = value32;
fMuteLastChanged = now; fMuteLastChanged = now;
BroadcastNewParameterValue(now, id, event->pointer, size); BroadcastNewParameterValue(now, id, event->pointer, size);
} else if(id == P_BYPASS) { } else if (id == P_BYPASS) {
fByPass = value32; fByPass = value32;
fByPassLastChanged = now; fByPassLastChanged = now;
BroadcastNewParameterValue(now, id, event->pointer, size); BroadcastNewParameterValue(now, id, event->pointer, size);
} else if(id == P_PREAMP) { } else if (id == P_PREAMP) {
if(value != fEqualizer.PreAmp()) { if (value != fEqualizer.PreAmp()) {
fEqualizer.SetPreAmp(value); fEqualizer.SetPreAmp(value);
fPreAmpLastChanged = now; fPreAmpLastChanged = now;
BroadcastNewParameterValue(now, id, &value, size); BroadcastNewParameterValue(now, id, &value, size);
} }
} else if(id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount()) { } else if (id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount()) {
int band = id - P_BANDS; int band = id - P_BANDS;
if(value != fEqualizer.Band(band)) { if (value != fEqualizer.Band(band)) {
fEqualizer.SetBand(band, value); fEqualizer.SetBand(band, value);
fBandsLastChanged[band] = now; fBandsLastChanged[band] = now;
BroadcastNewParameterValue(now, id, &value, size); BroadcastNewParameterValue(now, id, &value, size);
@@ -536,13 +559,14 @@ EqualizerNode::ParameterEventProcessing(const media_timed_event* event)
} }
} }
status_t status_t
EqualizerNode::ValidateFormat(const media_format &preferredFormat, EqualizerNode::ValidateFormat(const media_format &preferredFormat,
media_format &format) media_format &format)
{ {
status_t ret = B_OK; status_t ret = B_OK;
if(format.type != B_MEDIA_RAW_AUDIO) { if (format.type != B_MEDIA_RAW_AUDIO) {
format = preferredFormat; format = preferredFormat;
return B_MEDIA_BAD_FORMAT; return B_MEDIA_BAD_FORMAT;
} }
@@ -551,75 +575,70 @@ EqualizerNode::ValidateFormat(const media_format &preferredFormat,
media_raw_audio_format &f = format.u.raw_audio; media_raw_audio_format &f = format.u.raw_audio;
const media_raw_audio_format &pref = format.u.raw_audio; const media_raw_audio_format &pref = format.u.raw_audio;
if(pref.frame_rate != wild.frame_rate && f.frame_rate != pref.frame_rate) { if (pref.frame_rate != wild.frame_rate && f.frame_rate != pref.frame_rate) {
if(f.frame_rate != wild.frame_rate) { if (f.frame_rate != wild.frame_rate)
ret = B_MEDIA_BAD_FORMAT; ret = B_MEDIA_BAD_FORMAT;
}
f.frame_rate = pref.frame_rate; f.frame_rate = pref.frame_rate;
} }
if(pref.channel_count != wild.channel_count && f.channel_count != pref.channel_count) { if (pref.channel_count != wild.channel_count
if(f.channel_count != wild.channel_count) { && f.channel_count != pref.channel_count) {
if (f.channel_count != wild.channel_count)
ret = B_MEDIA_BAD_FORMAT; ret = B_MEDIA_BAD_FORMAT;
}
f.channel_count = pref.channel_count; f.channel_count = pref.channel_count;
} }
if(pref.byte_order != wild.byte_order && f.byte_order != pref.byte_order) { if (pref.byte_order != wild.byte_order && f.byte_order != pref.byte_order) {
if(f.byte_order != wild.byte_order) { if (f.byte_order != wild.byte_order)
ret = B_MEDIA_BAD_FORMAT; ret = B_MEDIA_BAD_FORMAT;
}
f.byte_order = pref.byte_order; f.byte_order = pref.byte_order;
} }
if(pref.format != wild.format && f.format != pref.format) { if (pref.format != wild.format && f.format != pref.format) {
if(f.format != wild.format) { if (f.format != wild.format)
ret = B_MEDIA_BAD_FORMAT; ret = B_MEDIA_BAD_FORMAT;
}
f.format = pref.format; f.format = pref.format;
} }
if(pref.buffer_size != wild.buffer_size && f.buffer_size != pref.buffer_size) { if (pref.buffer_size != wild.buffer_size
if(f.buffer_size != wild.buffer_size) { && f.buffer_size != pref.buffer_size) {
if (f.buffer_size != wild.buffer_size)
ret = B_MEDIA_BAD_FORMAT; ret = B_MEDIA_BAD_FORMAT;
}
f.buffer_size = pref.buffer_size; f.buffer_size = pref.buffer_size;
} }
return ret; return ret;
} }
void void
EqualizerNode::SetOutputFormat(media_format &format) EqualizerNode::SetOutputFormat(media_format &format)
{ {
media_raw_audio_format &f = format.u.raw_audio; media_raw_audio_format &f = format.u.raw_audio;
media_raw_audio_format &w = media_raw_audio_format::wildcard; media_raw_audio_format &w = media_raw_audio_format::wildcard;
if(f.frame_rate == w.frame_rate) { if (f.frame_rate == w.frame_rate)
f.frame_rate = 44100.0; f.frame_rate = 44100.0;
}
if(f.channel_count == w.channel_count) { if (f.channel_count == w.channel_count) {
if(fInputMedia.source != media_source::null) { if (fInputMedia.source != media_source::null)
f.channel_count = fInputMedia.format.u.raw_audio.channel_count; f.channel_count = fInputMedia.format.u.raw_audio.channel_count;
} else { else
f.channel_count = 2; f.channel_count = 2;
}
} }
if(f.format == w.format) { if (f.format == w.format)
f.format = media_raw_audio_format::B_AUDIO_FLOAT; f.format = media_raw_audio_format::B_AUDIO_FLOAT;
}
if(f.byte_order == w.format) { if (f.byte_order == w.format)
f.byte_order = (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN; f.byte_order = (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN
} : B_MEDIA_LITTLE_ENDIAN;
if(f.buffer_size == w.buffer_size) { if (f.buffer_size == w.buffer_size)
f.buffer_size = BUFF_SIZE; f.buffer_size = BUFF_SIZE;
}
} }
void void
EqualizerNode::InitParameterValues() EqualizerNode::InitParameterValues()
{ {
@@ -629,44 +648,46 @@ EqualizerNode::InitParameterValues()
fByPassLastChanged = 0LL; fByPassLastChanged = 0LL;
fPreAmpLastChanged = 0LL; fPreAmpLastChanged = 0LL;
for(int i=0;i<EQ_BANDS;i++) { for (int i = 0; i < EQ_BANDS; i++)
fBandsLastChanged[i] = 0LL; fBandsLastChanged[i] = 0LL;
}
fEqualizer.CleanUp(); fEqualizer.CleanUp();
} }
void void
EqualizerNode::InitParameterWeb(void) EqualizerNode::InitParameterWeb(void)
{ {
fWeb = new BParameterWeb(); fWeb = new BParameterWeb();
BParameterGroup *fParamGroup = fWeb->MakeGroup("EqualizerNode Parameters"); BParameterGroup* fParamGroup = fWeb->MakeGroup("EqualizerNode Parameters");
BParameterGroup *fFControlGroup = fParamGroup->MakeGroup("FilterControl"); BParameterGroup* fFControlGroup = fParamGroup->MakeGroup("FilterControl");
fFControlGroup->MakeDiscreteParameter(P_MUTE,B_MEDIA_NO_TYPE,"Mute", B_ENABLE); fFControlGroup->MakeDiscreteParameter(P_MUTE,B_MEDIA_NO_TYPE,"Mute",
fFControlGroup->MakeDiscreteParameter(P_BYPASS,B_MEDIA_NO_TYPE,"ByPass", B_ENABLE); B_ENABLE);
fFControlGroup->MakeDiscreteParameter(P_BYPASS,B_MEDIA_NO_TYPE,"ByPass",
B_ENABLE);
BNullParameter *label; BNullParameter* label;
BParameterGroup *group; BParameterGroup* group;
BContinuousParameter *value; BContinuousParameter* value;
group = fParamGroup->MakeGroup("Pre Amp"); group = fParamGroup->MakeGroup("Pre Amp");
label = group->MakeNullParameter(P_PREAMP_LABEL, B_MEDIA_NO_TYPE, label = group->MakeNullParameter(P_PREAMP_LABEL, B_MEDIA_NO_TYPE, "Pre Amp",
"Pre Amp", B_GENERIC); B_GENERIC);
value = group->MakeContinuousParameter(P_PREAMP, B_MEDIA_NO_TYPE, value = group->MakeContinuousParameter(P_PREAMP, B_MEDIA_NO_TYPE, "",
"", B_GAIN, "dB", -8.0, 8.0, 0.1); B_GAIN, "dB", -8.0, 8.0, 0.1);
label->AddOutput(value); label->AddOutput(value);
value->AddInput(label); value->AddInput(label);
for(int i=0; i<fEqualizer.BandCount(); i++) { for (int i = 0; i < fEqualizer.BandCount(); i++) {
char freq[32]; char freq[32];
sprintf(freq,"%gHz",fEqualizer.BandFrequency(i)); sprintf(freq,"%gHz",fEqualizer.BandFrequency(i));
group = fParamGroup->MakeGroup(freq); group = fParamGroup->MakeGroup(freq);
label = group->MakeNullParameter(P_BAND_LABELS + i, B_MEDIA_NO_TYPE, label = group->MakeNullParameter(P_BAND_LABELS + i, B_MEDIA_NO_TYPE,
freq, B_GENERIC); freq, B_GENERIC);
value = group->MakeContinuousParameter(P_BANDS + i, B_MEDIA_NO_TYPE, value = group->MakeContinuousParameter(P_BANDS + i, B_MEDIA_NO_TYPE,
"", B_GAIN, "dB", -16.0, 16.0, 0.1); "", B_GAIN, "dB", -16.0, 16.0, 0.1);
label->AddOutput(value); label->AddOutput(value);
value->AddInput(label); value->AddInput(label);
} }
@@ -674,22 +695,26 @@ EqualizerNode::InitParameterWeb(void)
SetParameterWeb(fWeb); SetParameterWeb(fWeb);
} }
void void
EqualizerNode::InitFilter(void) EqualizerNode::InitFilter(void)
{ {
fEqualizer.SetFormat(fFormat.u.raw_audio.channel_count, fFormat.u.raw_audio.frame_rate); fEqualizer.SetFormat(fFormat.u.raw_audio.channel_count,
fFormat.u.raw_audio.frame_rate);
} }
bigtime_t bigtime_t
EqualizerNode::GetFilterLatency(void) EqualizerNode::GetFilterLatency(void)
{ {
if(fOutputMedia.destination == media_destination::null) { if (fOutputMedia.destination == media_destination::null)
return 0LL; return 0LL;
}
BBufferGroup *test_group = new BBufferGroup(fOutputMedia.format.u.raw_audio.buffer_size, 1); 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); BBuffer* buffer =
test_group->RequestBuffer(fOutputMedia.format.u.raw_audio.buffer_size);
buffer->Header()->type = B_MEDIA_RAW_AUDIO; buffer->Header()->type = B_MEDIA_RAW_AUDIO;
buffer->Header()->size_used = fOutputMedia.format.u.raw_audio.buffer_size; buffer->Header()->size_used = fOutputMedia.format.u.raw_audio.buffer_size;
@@ -705,17 +730,16 @@ EqualizerNode::GetFilterLatency(void)
return latency; return latency;
} }
void void
EqualizerNode::FilterBuffer(BBuffer* buffer) EqualizerNode::FilterBuffer(BBuffer* buffer)
{ {
uint32 m_frameSize = (fFormat.u.raw_audio.format & 0x0f) * fFormat.u.raw_audio.channel_count; uint32 m_frameSize = (fFormat.u.raw_audio.format & 0x0f)
* fFormat.u.raw_audio.channel_count;
uint32 samples = buffer->Header()->size_used / m_frameSize; uint32 samples = buffer->Header()->size_used / m_frameSize;
uint32 channels = fFormat.u.raw_audio.channel_count; uint32 channels = fFormat.u.raw_audio.channel_count;
if(fMute !=0 ) { if (fMute != 0)
memset(buffer->Data(), 0, buffer->Header()->size_used); memset(buffer->Data(), 0, buffer->Header()->size_used);
} else { else if (fByPass == 0)
if(fByPass == 0) { fEqualizer.ProcessBuffer((float*)buffer->Data(), samples * channels);
fEqualizer.ProcessBuffer((float*)buffer->Data(), samples*channels);
}
}
} }