name: Bark

synopsis:

g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_numeric.a

#include <Bark.h>

boolean compute(VectorFloat& bark, const VectorFloat& freq);

quick start:

VectorFloat freq(1);
VectorFloat bark;

freq(0) = 1000;
Bark::compute(bark, freq);

description:

The Bark class implements a function that is commonly used to map frequency in Hz to a scale that is more perceptually-meaningful. The units of this scale are referred to as critical band rate, or Bark. The approximation for the Bark scale that is implemented in this class is given by:

  Bark = 13 atan(0.76 * freq / 1000) + 3.5 atan(freq ^ 2 / 7500 ^ 2)

For more details about this transformation, see:

J. Picone,

"Signal Modeling Techniques in Speech Recognition,"

IEEE Proceedings

See the Mel class for an alternate way to approximate this scale.

dependencies:

public constants:

define the class name:

static const String CLASS_NAME = L"Bark";

define i/o related constants:
```
static const String DEF_PARAM = L"";
```

define constants used to implement the approximation:

static const float A1 = 13.0;

static const float A2 = 0.76 / 1000.0;

static const float B1 = 3.5;

static const float B2 = 1.0 / 7500.0;

error codes:

error code indicating Bark class general error:
```
static const long ERR = (long)35300;
```

protected data:

debug level:
```
static Integral::DEBUG debug_level_d;
```
a static memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods:

static const String& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods:

boolean setDebug(Integral::DEBUG debug_level);

boolean debug(const unichar* message) const;

destructor/constructor(s):
```
~Bark();
```
```
Bark();
```
```
Bark(const Bark& arg);
```
assign methods:
```
boolean assign(const Bark& arg)
```
operator= methods:
```
Bark& operator= (const Bark& arg);
```

i/o methods:

long sofSize() const;

boolean read(Sof& sof, long tag, const String& name = CLASS_NAME);

boolean write(Sof& sof, long tag, const String& name = CLASS_NAME) const;

boolean readData(Sof& sof, const String& pname = DEF_PARAM,long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;

equality methods:
```
boolean eq(const Bark& arg) const;
```

memory management methods:

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE ctype = Integral::DEF_CMODE);

class-specific public methods:

computational methods

static boolean compute(float& bark, float freq);

static boolean compute(VectorFloat& bark, const VectorFloat& freq);

private methods:

none.

examples:

This example shows how to apply the Bark transformation of an input vector:

#include <Bark.h>
#include <VectorFloat.h>

int main() {

  // declare the input and output vectors
  //
  VectorFloat freq(L"100, 200, 300, 400, 500, 600");
  VectorFloat bark;

  // transform the input using the Bark scale
  //
  Bark::compute(bark, freq);

  // exit gracefully
  //
  Integral::exit();
}

notes:

This class has no internal data, so its compute function can be invoked as a static function call (the class need not be instantiated).