Add cyanogen-dsp library (initial import).

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

ifneq ($(HAVE_2_3_DSP), 1)

LOCAL_MODULE := libcyanogen-dsp

LOCAL_MODULE_TAGS := optional

LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/soundfx

LOCAL_PRELINK_MODULE := false

LOCAL_ARM_MODE := arm

LOCAL_SRC_FILES := \

	cyanogen-dsp.cpp \

	Biquad.cpp \

	Delay.cpp \

	Effect.cpp \

	EffectBassBoost.cpp \

	EffectCompression.cpp \

	EffectEqualizer.cpp \

	EffectVirtualizer.cpp \

# terminator

LOCAL_C_INCLUDES += \

	frameworks/base/include \

# terminator

LOCAL_SHARED_LIBRARIES := \

	libcutils

include $(BUILD_SHARED_LIBRARY)

endif

/*

 * Copyright (C) 2011 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include "Biquad.h"

#include <math.h>

static int64_t toFixedPoint(float in) {

    return int64_t(0.5 + in * (int64_t(1) << 32));

}

Biquad::Biquad()

{

    reset();

    setCoefficients(1, 0, 0, 0, 0, 0);

}

Biquad::~Biquad()

{

}

void Biquad::setCoefficients(float a0, float a1, float a2, float b0, float b1, float b2)

{

    mA1 = -toFixedPoint(a1/a0);

    mA2 = -toFixedPoint(a2/a0);

    mB0 = toFixedPoint(b0/a0);

    mB1 = toFixedPoint(b1/a0);

    mB2 = toFixedPoint(b2/a0);

}

void Biquad::reset()

{

    mX1 = 0;

    mX2 = 0;

    mY1 = 0;

    mY2 = 0;

}

void Biquad::setHighShelf(float center_frequency, float sampling_frequency, float db_gain, float slope)

{

    float w0 = 2 * (float) M_PI * center_frequency / sampling_frequency;

    float A = powf(10, db_gain/40);

    float alpha = sinf(w0)/2 * sqrtf( (A + 1/A)*(1/slope - 1) + 2 );

    float b0 =    A*( (A+1) + (A-1)*cosf(w0) + 2*sqrtf(A)*alpha );

    float b1 = -2*A*( (A-1) + (A+1)*cosf(w0)                   );

    float b2 =    A*( (A+1) + (A-1)*cosf(w0) - 2*sqrtf(A)*alpha );

    float a0 =        (A+1) - (A-1)*cosf(w0) + 2*sqrtf(A)*alpha  ;

    float a1 =    2*( (A-1) - (A+1)*cosf(w0)                   );

    float a2 =        (A+1) - (A-1)*cosf(w0) - 2*sqrtf(A)*alpha  ;

    setCoefficients(a0, a1, a2, b0, b1, b2);

}

void Biquad::setBandPass(float center_frequency, float sampling_frequency, float resonance)

{

    float w0 = 2 * (float) M_PI * center_frequency / sampling_frequency;

    float alpha = sinf(w0) / (2*resonance);

    float b0 =   sinf(w0)/2;

    float b1 =   0;

    float b2 =  -sinf(w0)/2;

    float a0 =   1 + alpha;

    float a1 =  -2*cosf(w0);

    float a2 =   1 - alpha;

    setCoefficients(a0, a1, a2, b0, b1, b2);

}

void Biquad::setLowPass(float center_frequency, float sampling_frequency, float resonance)

{

    float w0 = 2 * (float) M_PI * center_frequency / sampling_frequency;

    float alpha = sinf(w0) / (2*resonance);

    float b0 =  (1 - cosf(w0))/2;

    float b1 =   1 - cosf(w0);

    float b2 =  (1 - cosf(w0))/2;

    float a0 =   1 + alpha;

    float a1 =  -2*cosf(w0);

    float a2 =   1 - alpha;

    setCoefficients(a0, a1, a2, b0, b1, b2);

}

int32_t Biquad::process(int32_t x0)

{

    int64_t y0 = mB0 * x0

    	+ mB1 * mX1

        + mB2 * mX2

        + mA1 * mY1

        + mA2 * mY2;

    y0 >>= 32;

    mY2 = mY1;

    mY1 = y0;

    mX2 = mX1;

    mX1 = x0;

    return y0;

}

#pragma once

#include <stdint.h>

class Biquad {

    protected:

    int32_t mX1, mX2;

    int32_t mY1, mY2;

    int64_t mB0, mB1, mB2, mA1, mA2;

    void setCoefficients(float a0, float a1, float a2, float b0, float b1, float b2);

    public:

    Biquad();

    virtual ~Biquad();

    void setHighShelf(float cf, float sf, float gain, float slope);

    void setBandPass(float cf, float sf, float resonance);

    void setLowPass(float cf, float sf, float resonance);

    int32_t process(int32_t in);

    void reset();

};

/*

 * Copyright (C) 2011 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include "Delay.h"

#include <string.h>

Delay::Delay()

    : mState(0), mIndex(0), mLength(0)

{

}

Delay::~Delay()

{

    if (mState != 0) {

        delete[] mState;

        mState = 0;

    }

}

void Delay::setParameters(float samplingFrequency, float time)

{

    mLength = int32_t(time * samplingFrequency + 0.5f);

    if (mState != 0) {

        delete[] mState;

    }

    mState = new int32_t[mLength];

    memset(mState, 0, mLength * sizeof(int32_t));

    mIndex = 0;

}

int32_t Delay::process(int32_t x0)

{

    int32_t y0 = mState[mIndex];

    mState[mIndex] = x0;

    mIndex = (mIndex + 1) % mLength;

    return y0;

}

#pragma once

#include <stdint.h>

class Delay {

    int32_t* mState;

    int32_t mIndex;

    int32_t mLength;

    public:

    Delay();

    ~Delay();

    void setParameters(float rate, float time);

    int32_t process(int32_t x0);

};