[haiku-commits] haiku: hrev44699 - src/add-ons/media/media-add-ons/equalizer
- From: stpere@xxxxxxxxx
- To: haiku-commits@xxxxxxxxxxxxx
- Date: Sat, 13 Oct 2012 22:05:15 +0200 (CEST)
hrev44699 adds 1 changeset to branch 'master'
old head: 9815f07dce9ca0d0ec087dde46af7dbe6853b1dc
new head: 56bc38cef0bd924bac22f605e7ae493996e506b1
----------------------------------------------------------------------------
56bc38c: Coding style fixes, should have no functional changes.
[ Philippe Saint-Pierre <stpere@xxxxxxxxx> ]
----------------------------------------------------------------------------
Revision: hrev44699
Commit: 56bc38cef0bd924bac22f605e7ae493996e506b1
URL: http://cgit.haiku-os.org/haiku/commit/?id=56bc38c
Author: Philippe Saint-Pierre <stpere@xxxxxxxxx>
Date: Sat Oct 13 20:04:18 2012 UTC
----------------------------------------------------------------------------
1 file changed, 231 insertions(+), 207 deletions(-)
.../media-add-ons/equalizer/EqualizerNode.cpp | 438 ++++++++--------
----------------------------------------------------------------------------
diff --git a/src/add-ons/media/media-add-ons/equalizer/EqualizerNode.cpp
b/src/add-ons/media/media-add-ons/equalizer/EqualizerNode.cpp
index 79eb6fa..9479865 100644
--- a/src/add-ons/media/media-add-ons/equalizer/EqualizerNode.cpp
+++ b/src/add-ons/media/media-add-ons/equalizer/EqualizerNode.cpp
@@ -1,5 +1,6 @@
/*
- * Copyright 2012, Gerasim Troeglazov (3dEyes**), 3dEyes@xxxxxxxxxx All rights
reserved.
+ * Copyright 2012, Gerasim Troeglazov (3dEyes**), 3dEyes@xxxxxxxxxx
+ * All rights reserved.
* Distributed under the terms of the MIT License.
*/
@@ -16,11 +17,14 @@
#include "EqualizerNode.h"
//EqualizerNode
-EqualizerNode::~EqualizerNode() {
+EqualizerNode::~EqualizerNode()
+{
Quit();
}
-EqualizerNode::EqualizerNode(BMediaAddOn* addon) :
+
+EqualizerNode::EqualizerNode(BMediaAddOn* addon)
+ :
BMediaNode("10 Band Equalizer"),
BBufferConsumer(B_MEDIA_RAW_AUDIO),
BBufferProducer(B_MEDIA_RAW_AUDIO),
@@ -33,30 +37,32 @@ EqualizerNode::EqualizerNode(BMediaAddOn* addon) :
{
}
+
//BMediaNode
BMediaAddOn*
-EqualizerNode::AddOn(int32 *id) const
+EqualizerNode::AddOn(int32* id) const
{
- if(fAddOn)
+ 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) &&
+ 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);
+ (BControllable::HandleMessage(message, data, size) != B_OK)) {
+ BMediaNode::HandleMessage(message, data, size);
return B_OK;
- } else {
- BMediaNode::HandleBadMessage(message, data, size);
- return B_ERROR;
- }
+ }
+ BMediaNode::HandleBadMessage(message, data, size);
+ return B_ERROR;
}
+
void
EqualizerNode::NodeRegistered()
{
@@ -66,7 +72,8 @@ 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.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;
@@ -90,146 +97,153 @@ EqualizerNode::NodeRegistered()
InitParameterWeb();
}
+
//BControllable
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;
- }
- if(id == P_MUTE) {
+ if (id == P_MUTE) {
*(int32*)value = fMute;
*lastChangeTime = fMuteLastChanged;
*size = sizeof(int32);
- return B_OK;
- } else if(id == P_BYPASS) {
+ } else if (id == P_BYPASS) {
*(int32*)value = fByPass;
*lastChangeTime = fByPassLastChanged;
*size = sizeof(int32);
- return B_OK;
- } else if(id == P_PREAMP) {
+ } else if (id == P_PREAMP) {
*(float*)value = (float)fEqualizer.PreAmp();
*lastChangeTime = fPreAmpLastChanged;
*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;
*(float*)value = (float)fEqualizer.Band(band);
*lastChangeTime = fBandsLastChanged[band];
*size = sizeof(float);
- return B_OK;
- }
-
- return B_ERROR;
+ } else
+ return B_ERROR;
+ return B_OK;
}
+
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 ||
- (id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount())) {
+ 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, "EQ");
- ParameterEventProcessing(&ev); //dirty hack for parameter
processing (mediakit bug????)
+ ParameterEventProcessing(&ev);
+ //dirty hack for parameter processing (mediakit bug????)
EventQueue()->AddEvent(ev);
}
}
+
//BBufferConsumer
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();
return;
}
- if(fOutputMedia.destination == media_destination::null ||
!fOutputMediaEnabled) {
+ 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) {
+ 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)
+EqualizerNode::AcceptFormat(const media_destination &dst, media_format* format)
{
- if(dst != fInputMedia.destination) {
+ if (dst != fInputMedia.destination)
return B_MEDIA_BAD_DESTINATION;
- }
- if(format->type != B_MEDIA_RAW_AUDIO) {
+
+ 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);
-
+ 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) {
+ 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)
+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)
+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);
- }
}
+
status_t
-EqualizerNode::GetLatencyFor( const media_destination &dst, bigtime_t
*latency,
- media_node_id*
outTimeSource)
+EqualizerNode::GetLatencyFor(const media_destination &dst, bigtime_t* latency,
+ media_node_id* outTimeSource)
{
- if(dst != fInputMedia.destination) {
+ 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) {
+ if (destination != fInputMedia.destination)
return B_MEDIA_BAD_DESTINATION;
- }
- if(fInputMedia.source != media_source::null) {
+
+ if (fInputMedia.source != media_source::null)
return B_MEDIA_ALREADY_CONNECTED;
- }
fInputMedia.source = source;
fInputMedia.format = format;
@@ -239,125 +253,132 @@ EqualizerNode::Connected(const media_source& source,
return B_OK;
}
+
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;
- }
+
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;
- }
+
fInputMedia.format = fFormat;
}
+
//BBufferProducer
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;
- }
- 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;
- } else {
+ else
*format = fPreferredFormat;
- }
return B_OK;
}
+
status_t
EqualizerNode::FormatProposal(const media_source &src, media_format* format)
{
- if(src != fOutputMedia.source) {
+ if (src != fOutputMedia.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;
- }
- ValidateFormat((fFormat.u.raw_audio.format !=
media_raw_audio_format::wildcard.format) ?
- fFormat:fPreferredFormat,*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_)
+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)
+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;
- }
+
NotifyLateProducer(fInputMedia.source, late, when);
}
+
status_t
-EqualizerNode::GetNextOutput(int32 *cookie, media_output* output)
+EqualizerNode::GetNextOutput(int32* cookie, media_output* output)
{
- if(*cookie) {
+ 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)
+EqualizerNode::SetBufferGroup(const media_source &src, BBufferGroup* group)
{
int32 changeTag;
status_t ret = B_OK;
- if(src != fOutputMedia.source) {
+ if (src != fOutputMedia.source)
return B_MEDIA_BAD_SOURCE;
- }
- if(fInputMedia.source == media_source::null) {
+
+ if (fInputMedia.source == media_source::null)
return B_ERROR;
- }
- ret = SetOutputBuffersFor(fInputMedia.source, fInputMedia.destination,
group, 0, &changeTag);
+ 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)
+EqualizerNode::PrepareToConnect(const media_source &src,
+ 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;
- }
- if(format->type != B_MEDIA_RAW_AUDIO) {
+ if (format->type != B_MEDIA_RAW_AUDIO)
return B_MEDIA_BAD_FORMAT;
- }
- if(fOutputMedia.destination != media_destination::null) {
+ 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);
+ status_t err = ValidateFormat((fFormat.u.raw_audio.format
+ != media_raw_audio_format::wildcard.format) ? fFormat
+ : fPreferredFormat, *format);
- if(err < B_OK) {
+ if (err < B_OK)
return err;
- }
SetOutputFormat(*format);
@@ -370,12 +391,13 @@ EqualizerNode::PrepareToConnect( const media_source &src,
const media_destinatio
return B_OK;
}
+
void
-EqualizerNode::Connect(status_t status, const media_source &src, const
media_destination &dst,
- const media_format &format,
char *outName)
+EqualizerNode::Connect(status_t status, const media_source &src,
+ const media_destination &dst, const media_format &format, char* outName)
{
status_t err;
- if(status < B_OK) {
+ if (status < B_OK) {
fOutputMedia.destination = media_destination::null;
return;
}
@@ -385,86 +407,87 @@ EqualizerNode::Connect(status_t status, const
media_source &src, const media_des
fFormat = format;
media_node_id timeSource;
- err = FindLatencyFor(fOutputMedia.destination, &fDownstreamLatency,
&timeSource);
+ err = FindLatencyFor(fOutputMedia.destination, &fDownstreamLatency,
+ &timeSource);
InitFilter();
fProcessLatency = GetFilterLatency();
SetEventLatency(fDownstreamLatency + fProcessLatency);
- if(fInputMedia.source != media_source::null) {
+ if (fInputMedia.source != media_source::null) {
SendLatencyChange(fInputMedia.source, fInputMedia.destination,
- EventLatency() +
SchedulingLatency());
+ EventLatency() + SchedulingLatency());
}
bigtime_t duration = 0;
- int sample_size = (fFormat.u.raw_audio.format & 0xf) *
-
fFormat.u.raw_audio.channel_count;
+ 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);
+ 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) {
+ if (src != fOutputMedia.source)
return;
- }
- if(dst != fOutputMedia.destination) {
+ if (dst != fOutputMedia.destination)
return;
- }
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;
- }
fOutputMedia.format = fFormat;
}
+
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;
- }
fOutputMediaEnabled = enabled;
}
+
status_t
-EqualizerNode::GetLatency(bigtime_t *latency)
+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)
+EqualizerNode::LatencyChanged(const media_source &src,
+ const media_destination &dst, bigtime_t latency, uint32 flags)
{
- if(src != fOutputMedia.source || dst != fOutputMedia.destination) {
+ if (src != fOutputMedia.source || dst != fOutputMedia.destination)
return;
- }
fDownstreamLatency = latency;
SetEventLatency(fDownstreamLatency + fProcessLatency);
- if(fInputMedia.source != media_source::null) {
+ if (fInputMedia.source != media_source::null) {
SendLatencyChange(fInputMedia.source,
- fInputMedia.destination,EventLatency()
+ SchedulingLatency());
+ fInputMedia.destination,EventLatency() +
SchedulingLatency());
}
}
+
//BMediaEventLooper
bigtime_t
EqualizerNode::OfflineTime()
@@ -472,17 +495,17 @@ EqualizerNode::OfflineTime()
return 0LL;
}
+
//EqualizerNode
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);
- }
}
-
void
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;
- 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);
- if(web_param->ID() == id) {
+ if (web_param->ID() == id) {
v_type=web_param->ValueType();
break;
}
}
- if(v_type == B_FLOAT_TYPE)
+ if (v_type == B_FLOAT_TYPE)
value = *((float*)event->pointer);
- if(v_type == B_INT32_TYPE) {
+ else if (v_type == B_INT32_TYPE) {
value32 = *((int32*)event->pointer);
value = (float)value32;
}
- if(id == P_MUTE) {
+ if (id == P_MUTE) {
fMute = value32;
fMuteLastChanged = now;
BroadcastNewParameterValue(now, id, event->pointer, size);
- } else if(id == P_BYPASS) {
+ } else if (id == P_BYPASS) {
fByPass = value32;
fByPassLastChanged = now;
BroadcastNewParameterValue(now, id, event->pointer, size);
- } else if(id == P_PREAMP) {
- if(value != fEqualizer.PreAmp()) {
+ } 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()) {
+ } else if (id >= P_BANDS && id < P_BANDS + fEqualizer.BandCount()) {
int band = id - P_BANDS;
- if(value != fEqualizer.Band(band)) {
+ if (value != fEqualizer.Band(band)) {
fEqualizer.SetBand(band, value);
fBandsLastChanged[band] = now;
BroadcastNewParameterValue(now, id, &value, size);
@@ -536,13 +559,14 @@ EqualizerNode::ParameterEventProcessing(const
media_timed_event* event)
}
}
+
status_t
EqualizerNode::ValidateFormat(const media_format &preferredFormat,
- media_format &format)
+ media_format &format)
{
status_t ret = B_OK;
- if(format.type != B_MEDIA_RAW_AUDIO) {
+ if (format.type != B_MEDIA_RAW_AUDIO) {
format = preferredFormat;
return B_MEDIA_BAD_FORMAT;
}
@@ -551,75 +575,70 @@ EqualizerNode::ValidateFormat(const media_format
&preferredFormat,
media_raw_audio_format &f = 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(f.frame_rate != wild.frame_rate) {
+ 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) {
+ 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.byte_order != wild.byte_order && f.byte_order !=
pref.byte_order) {
- if(f.byte_order != wild.byte_order) {
+ 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.format != wild.format && f.format != pref.format) {
- if(f.format != wild.format) {
+ 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.buffer_size != wild.buffer_size && f.buffer_size !=
pref.buffer_size) {
- if(f.buffer_size != wild.buffer_size) {
+ 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;
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;
- }
- if(f.channel_count == w.channel_count) {
- if(fInputMedia.source != media_source::null) {
+ if (f.channel_count == w.channel_count) {
+ if (fInputMedia.source != media_source::null)
f.channel_count =
fInputMedia.format.u.raw_audio.channel_count;
- } else {
+ else
f.channel_count = 2;
- }
}
- if(f.format == w.format) {
+ 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.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) {
+ if (f.buffer_size == w.buffer_size)
f.buffer_size = BUFF_SIZE;
- }
}
+
void
EqualizerNode::InitParameterValues()
{
@@ -629,44 +648,46 @@ EqualizerNode::InitParameterValues()
fByPassLastChanged = 0LL;
fPreAmpLastChanged = 0LL;
- for(int i=0;i<EQ_BANDS;i++) {
+ 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");
+ 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);
+ 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;
+ 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 = 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++) {
+ 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);
+ freq, B_GENERIC);
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);
value->AddInput(label);
}
@@ -674,22 +695,26 @@ EqualizerNode::InitParameterWeb(void)
SetParameterWeb(fWeb);
}
+
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
EqualizerNode::GetFilterLatency(void)
{
- if(fOutputMedia.destination == media_destination::null) {
+ if (fOutputMedia.destination == media_destination::null)
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()->size_used =
fOutputMedia.format.u.raw_audio.buffer_size;
@@ -705,17 +730,16 @@ EqualizerNode::GetFilterLatency(void)
return latency;
}
+
void
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 channels = fFormat.u.raw_audio.channel_count;
- if(fMute !=0 ) {
+ if (fMute != 0)
memset(buffer->Data(), 0, buffer->Header()->size_used);
- } else {
- if(fByPass == 0) {
- fEqualizer.ProcessBuffer((float*)buffer->Data(),
samples*channels);
- }
- }
+ else if (fByPass == 0)
+ fEqualizer.ProcessBuffer((float*)buffer->Data(), samples *
channels);
}
Other related posts:
