/*

* Copyright (c) 2005-2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Manipulates the equalization settings of a Player.

*

*/

// INCLUDE FILES

#include <jdebug.h>

#include "cammsemcequalizercontrol.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

CAMMSEMCEqualizerControl* CAMMSEMCEqualizerControl::NewLC(CMMAPlayer* aPlayer)

{

    CAMMSEMCEqualizerControl* self =

        new(ELeave) CAMMSEMCEqualizerControl(aPlayer);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

// Destructor

CAMMSEMCEqualizerControl::~CAMMSEMCEqualizerControl()

{

    DEBUG("AMMS::CAMMSEMCEqualizerControl::~CAMMSEMCEqualizerControl");

    // Perform DeallocateControl, if the state change has not yet performed it.

    DeallocateControl();

    if (iAMMSEMCEqualizerEnvironmentalPresetUtility)

        delete iAMMSEMCEqualizerEnvironmentalPresetUtility;

    delete iPresetNames;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::BandLevelL

// Gets the gain set for the given equalizer band.

// -----------------------------------------------------------------------------

//

TInt CAMMSEMCEqualizerControl::BandLevelL(TInt aBand)

{

    // if aBand is out of range the method must leave with KErrArgument.

    if (aBand < 0 || aBand > (NumberOfBands() - 1))

    {

        User::Leave(KErrArgument);

    }

    // Returns the band level in mB for the specified band

    TInt bandlevel;

    TInt aNativeBand = aBand + KAMMSBandOffset;

    iMEqualizerControl->BandLevel(aNativeBand,bandlevel);

    return bandlevel;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::MaxBandLevel

// Returns the maximum band level supported.

// -----------------------------------------------------------------------------

//

TInt CAMMSEMCEqualizerControl::MaxBandLevel()

{

    // Get the dB range in mB for the equalizer.

    TInt min,max;

    iMEqualizerControl->DbLevelLimits(min,max);

    return max;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::MinBandLevel

// Returns the minimum band level supported.

// -----------------------------------------------------------------------------

//

TInt CAMMSEMCEqualizerControl::MinBandLevel()

{

    // Get the dB range in mB for the equalizer.

    TInt min,max;

    iMEqualizerControl->DbLevelLimits(min,max);

    return min;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::BandWidth

// Returns the band width in Hz for the specified band.

// -----------------------------------------------------------------------------

//

TInt CAMMSEMCEqualizerControl::BandWidth(TInt aBand)

{

    TInt bndwdth;

    TInt aNativeBand = aBand + KAMMSBandOffset;

    iMEqualizerControl->BandWidth(aNativeBand,bndwdth);

    return bndwdth;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::CenterFrequency

// Returns the center frequency in Hz for a given band.

// -----------------------------------------------------------------------------

//

TInt CAMMSEMCEqualizerControl::CenterFrequency(TInt aBand)

{

    TInt cntrfreq;

    TInt aNativeBand = aBand + KAMMSBandOffset;

    iMEqualizerControl->CenterFrequency(aNativeBand,cntrfreq);

    return cntrfreq;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::CrossoverFrequency

// Returns the cross-over frequency between the given frequency.

// -----------------------------------------------------------------------------

//

TInt CAMMSEMCEqualizerControl::CrossoverFrequency(TInt aBand)

{

    TInt aCrossOverFreq;

    TInt aNativeBand = aBand + KAMMSBandOffset;

    iMEqualizerControl->CrossoverFrequency(aNativeBand, aCrossOverFreq);

    return aCrossOverFreq;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::NumberOfBands

// Gets the number of frequency bands that the equalizer supports.

// -----------------------------------------------------------------------------

//

TInt CAMMSEMCEqualizerControl::NumberOfBands()

{

    // Returns the number of equalizer bands.

    // AudioEqualizerBase: TUint8 NumberOfBands() const;

    TInt aNumOfBands;

    iMEqualizerControl->NumberOfBands(aNumOfBands);

    return aNumOfBands;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::SetBandLevelL

// Sets the given equalizer band to the given gain value.

// -----------------------------------------------------------------------------

//

void CAMMSEMCEqualizerControl::SetBandLevelL(

    TInt aLevel,

    TInt aBand)

{

    DEBUG_INT2("AMMS::CAMMSEMCEqualizerControl::SetBandLevelL: level=%d, band=%d",

               aLevel, aBand);

    // If aBand or aLevel is out of valid range the method must leave

    // with KErrArgument.

    if (aBand < 0 ||

            aBand > (NumberOfBands() - 1) ||

            aLevel < MinBandLevel() ||

            aLevel > MaxBandLevel())

    {

        User::Leave(KErrArgument);

    }

    TInt aNativeBand = aBand + KAMMSBandOffset;

    // Sets the equalizer band level value in mB, ranging from Min to Max

    iMEqualizerControl->SetBandLevel(aNativeBand, aLevel);

    ApplySettingsL();

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::SetPresetL

// Sets the effect according to the given preset.

// -----------------------------------------------------------------------------

//

void CAMMSEMCEqualizerControl::SetPresetL(const TDesC& aPreset)

{

    DEBUG_STR("AMMS::CAMMSEMCEqualizerControl::SetPresetL \"%S\"", aPreset);

    CAudioEqualizer *iAudioEqualizer = NULL;

    iAMMSEMCEqualizerEnvironmentalPresetUtility->PrepareEmptyEqualizerUtilitiesL();

    iAMMSEMCEqualizerEnvironmentalPresetUtility->GetPresetNamesL(*iPresetNames);

    TInt presetPosition = 0;

    TInt findPreset = iPresetNames->Find(aPreset, presetPosition);

    if (findPreset == 0)  // Find returns zero, if a matching element is found.

    {

        iAudioEqualizer = iAMMSEMCEqualizerEnvironmentalPresetUtility->GetEqualizerAtPresetIndexL(presetPosition);

        iCurrentPreset = presetPosition;

    }

    else

    {

        iAMMSEMCEqualizerEnvironmentalPresetUtility->DeleteEmptyEqualizerUtilities();

        User::Leave(KErrArgument);

    }

    if (!iAudioEqualizer)

    {

        iAMMSEMCEqualizerEnvironmentalPresetUtility->DeleteEmptyEqualizerUtilities();

        return;

    }

    //Get all preset data here

    // For each band of AudioEqualizer get the band level and set it to iMEqualizerControl

    TInt noOfbands = iAudioEqualizer->NumberOfBands();

    for (TInt i = 0; i < noOfbands; i++)

    {

        // Band 0 in JSR-234 equals Band 1 in Effect API

        TInt aNativeBand =  i + KAMMSBandOffset;

        TInt iBandLevel = iAudioEqualizer->BandLevel(aNativeBand);

        iMEqualizerControl->SetBandLevel(aNativeBand, iBandLevel);

    }

    iMEqualizerControl->Apply();

    iAMMSEMCEqualizerEnvironmentalPresetUtility->DeleteEmptyEqualizerUtilities();

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::PresetNamesL

// Gets the available preset names.

// -----------------------------------------------------------------------------

//

const CDesCArray& CAMMSEMCEqualizerControl::PresetNamesL()

{

    // Returns an array of all preset names (pre-defined and user-defined).

    // The pre-defined presets are in the beginning of the list.

    iAMMSEMCEqualizerEnvironmentalPresetUtility->PrepareEmptyEqualizerUtilitiesL();

    iAMMSEMCEqualizerEnvironmentalPresetUtility->GetPresetNamesL(*iPresetNames);

    iAMMSEMCEqualizerEnvironmentalPresetUtility->DeleteEmptyEqualizerUtilities();

    return *iPresetNames;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::PresetL

// Gets the current preset.

// -----------------------------------------------------------------------------

//

const TDesC& CAMMSEMCEqualizerControl::PresetL()

{//if no preset is set, return null

    if (iCurrentPreset < 0)

    {

        return KNullDesC;

    }

    else

    {

        // Retrieves a Preset with the given index from the utility class

        iAMMSEMCEqualizerEnvironmentalPresetUtility->PrepareEmptyEqualizerUtilitiesL();  // codescanner::leave

        iAMMSEMCEqualizerEnvironmentalPresetUtility->GetPresetAtIndexL(iPresetName , iCurrentPreset);  // codescanner::leave

        iAMMSEMCEqualizerEnvironmentalPresetUtility->DeleteEmptyEqualizerUtilities();

        return iPresetName;

    }

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::SetEnabledL

// Enables/disables the effect.

// -----------------------------------------------------------------------------

//

void CAMMSEMCEqualizerControl::SetEnabledL(TBool aEnable)

{

    if (aEnable)

    {

        // Enable the effect.

        iMEqualizerControl->Enable();

        DEBUG("AMMS::CAMMSEMCEqualizerControl::SetEnabledL(true), calling Apply");

        iMEqualizerControl->Apply();

    }

    else

    {

        // Disable the effect

        DEBUG("AMMS::CAMMSEMCEqualizerControl::SetEnabledL(false), calling Disable");

        iMEqualizerControl->Disable();

        iMEqualizerControl->Apply();

    }

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::PrepareControlL

// Function which is called after the correct state is set in Player.

// -----------------------------------------------------------------------------

//

void CAMMSEMCEqualizerControl::PrepareControlL()

{

    // Perform the action only for the first time, skip if called afterwards

    if (!iMEqualizerControl)

    {

        DEBUG("AMMS::CAMMSEMCEqualizerControl::PrepareControlL");

        //Create Equalizer Effect Control

        iStreamControl = (static_cast<CMMAEMCAudioPlayer*>(iMMAPlayer))->StreamControl();

        iFactory = (static_cast<CMMAEMCAudioPlayer*>(iMMAPlayer))->MMFactory();

        MEffectControl* temp(NULL);

        User::LeaveIfError(iFactory->CreateEffectControl(KEqualizerEffectControl, temp));

        iMEqualizerControl  = static_cast<MEqualizerControl*>(temp);

        User::LeaveIfError(iStreamControl->AddEffect(*iMEqualizerControl));

        iMEqualizerControl->Enable();

    }

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::DeallocateControl

// Function which is called after the correct state is set in Player.

// -----------------------------------------------------------------------------

//

void CAMMSEMCEqualizerControl::DeallocateControl()

{

    if (iMEqualizerControl)

    {

        DEBUG("AMMS::CAMMSEMCEqualizerControl::DeallocateControl");

        // Equalizer for Audio can be disabled or enabled

        TRAPD(err,iMEqualizerControl->Disable());

        if (err != KErrNone)

        {

            //Some EMC Error

            DEBUG_INT("AMMS::CAMMSEMCEqualizerControl::DeallocateControl err = %d",err);

        }

        //return the control to factory

        MEffectControl* temp = iMEqualizerControl;

        iStreamControl->RemoveEffect(*temp);

        // Delete the Effect

        MEffectControl* tempCtrl = iMEqualizerControl;

        iFactory->DeleteEffectControl(tempCtrl);

        iMEqualizerControl = NULL;

    }

}

const TDesC& CAMMSEMCEqualizerControl::ClassName() const

{

    return KAMMSEMCEqualizerControl;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::SetEnforcedL

// Enforces the effect to be in use.

// -----------------------------------------------------------------------------

//

void CAMMSEMCEqualizerControl::SetEnforcedL(TBool aEnforced)

{

    DEBUG("AMMS::CAMMSEMCEqualizerControl:SetEnforcedL");

    // Indicate the effect is to be enforced or not. ETrue = Enforced.

    iMEqualizerControl->Enforce(aEnforced);

    ApplySettingsL();

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::Enforced

// Returns the current enforced setting of the effect.

// -----------------------------------------------------------------------------

//

TBool CAMMSEMCEqualizerControl::Enforced()

{

    // Returns ETrue if the effect is enforced, EFalse if not enforced.

    TBool enforced;

    iMEqualizerControl->IsEnforced(enforced);

    return enforced;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::SetScopeL

// Sets the scope of the effect.

// -----------------------------------------------------------------------------

//

void CAMMSEMCEqualizerControl::SetScopeL(TInt aScope)

{

    DEBUG("AMMS::CAMMSEMCEqualizerControl:SetScopeL");

    __ASSERT_DEBUG(

        (aScope == CAMMSEffectControlGroup::EScopeLiveOnly),

        User::Invariant());

    // Just to suppress warning in release build

    (void)aScope;

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::Scope

// Returns the scope in which the effect is present.

// -----------------------------------------------------------------------------

//

TInt CAMMSEMCEqualizerControl::Scope()

{

    // For now only the (LIVE_ONLY) scope is supported.

    return CAMMSEffectControlGroup::EScopeLiveOnly;

}

// -----------------------------------------------------------------------------

// CAMMSEMCAudioVirtualizerControl::ApplySettingsL

// Apply changed settings if Effect is in enabled state.

// -----------------------------------------------------------------------------

void CAMMSEMCEqualizerControl::ApplySettingsL()

{

    DEBUG("AMMS::CAMMSEMCEqualizerControl:ApplySettingsL called, checking state");

    TBool enabled;

    iMEqualizerControl->IsEnabled(enabled);

    if (enabled)

    {

        DEBUG("AMMS::CAMMSEMCEqualizerControl:ApplySettingsL calling ApplyL");

        iMEqualizerControl->Apply();

    }

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

void CAMMSEMCEqualizerControl::ConstructL()

{

    // Create array for preset names

    iPresetNames = new(ELeave) CDesCArrayFlat(1);

    // Set current preset to a negative value as it is not set yet

    iCurrentPreset = -1;

    CAMMSEffectControl::ConstructL();

    iAMMSEMCEqualizerEnvironmentalPresetUtility =  new(ELeave)CAMMSEMCEqualizerEnvironmentalPresetUtility;

    iAMMSEMCEqualizerEnvironmentalPresetUtility->ConstructL();

}

// -----------------------------------------------------------------------------

// CAMMSEMCEqualizerControl::CAMMSEMCEqualizerControl

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

CAMMSEMCEqualizerControl::CAMMSEMCEqualizerControl(CMMAPlayer* aPlayer)

        : CAMMSBaseEqualizerControl(aPlayer)

{

    iMMAPlayer = aPlayer;

}

//  End of File