/*
* Copyright (c) 2002 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:  This class is a TempoControl.
*
*/


//  INCLUDE FILES
#include <jdebug.h>
#include <e32base.h>

#include "cmmamiditempocontrol.h"
#include "cmmamidiplayer.h"

static const TInt KMicroBeatsInMiliBeat = 1000;
static const TInt KMMAMIDIMinimumTempo = 10000;
static const TInt KMMAMIDIMaximumTempo = 300000;
static const TInt KMMAMIDIDefaultTempoInMicroBeats = 120000000;
_LIT(KMMAMidiTempoStateChangedError, "Tempo error in state change");

CMMAMIDITempoControl* CMMAMIDITempoControl::NewL(CMMAMIDIPlayer* aPlayer)
{
    CMMAMIDITempoControl* self = new(ELeave) CMMAMIDITempoControl(aPlayer);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    return self;
}

CMMAMIDITempoControl::CMMAMIDITempoControl(CMMAMIDIPlayer* aPlayer)
{
    iPlayer = aPlayer;
    iTempo = KMMAMIDIDefaultTempoInMicroBeats;

    DEBUG("MMA:CMMAMIDITempoControl::CMMAMIDITempoControl");
}

CMMAMIDITempoControl::~CMMAMIDITempoControl()
{
    DEBUG("MMA:CMMAMIDITempoControl::~CMMAMIDITempoControl");
}

inline void CMMAMIDITempoControl::ConstructL()
{
    DEBUG("MMA:CMMAMIDITempoControl::ConstructL");

    iPlayer->addObserverL(this);
    iPlayer->AddStateListenerL(this);
}

const TDesC& CMMAMIDITempoControl::ClassName() const
{
    DEBUG("MMA:CMMAMIDITempoControl::ClassName");
    return KMIDITempoControlName;
}


TInt CMMAMIDITempoControl::TempoL()
{
    DEBUG("MMA: CMMAMIDITempoControl: TempoL");

    return iTempo / KMicroBeatsInMiliBeat;
}

TInt CMMAMIDITempoControl::SetTempoL(TInt aTempo)
{
    DEBUG("MMA: CMMAMIDITempoControl: SetTempoL");
    TInt tempo = aTempo;
    if (tempo < KMMAMIDIMinimumTempo)
    {
        tempo = KMMAMIDIMinimumTempo;
    }
    if (tempo > KMMAMIDIMaximumTempo)
    {
        tempo = KMMAMIDIMaximumTempo;
    }

    DEBUG_INT("MMA: CMMAMIDITempoControl: SetTempoL: setting tempo %d",
              tempo);

    // Convert tempo to micro-beats.
    tempo *= KMicroBeatsInMiliBeat;

    // Set the tempo to the midi client if the player state is not REALIZED.
    // (Tempo cannot be set to the midi client if the player
    // has not been prefetched).
    if (iPlayer->State() != CMMAPlayer::ERealized)
    {
        CMidiClientUtility* midi = iPlayer->MidiClient();
        midi->SetTempoL(tempo);
        tempo = iPlayer->MidiClient()->TempoMicroBeatsPerMinuteL();
    }

    iTempo = tempo;

    DEBUG_INT("MMA: CMMAMIDITempoControl: SetTempoL: Tempo set: %d",
              tempo / KMicroBeatsInMiliBeat);

    return tempo / KMicroBeatsInMiliBeat;
}

TInt CMMAMIDITempoControl::SetRateL(TInt aRate)
{
    TInt rate = aRate;
    TInt maxRate = MaxRateL();
    TInt minRate = MinRateL();

    if (rate > maxRate)
    {
        rate = maxRate;
    }
    else if (rate < minRate)
    {
        rate = minRate;
    }
    iPlayer->MidiClient()->SetPlaybackRateL(rate);
    return RateL();         // return the actual tempo
}

TInt CMMAMIDITempoControl::RateL()
{
    return iPlayer->MidiClient()->PlaybackRateL();
}

TInt CMMAMIDITempoControl::MaxRateL()
{
    return iPlayer->MidiClient()->MaxPlaybackRateL();
}

TInt CMMAMIDITempoControl::MinRateL()
{
    return iPlayer->MidiClient()->MinPlaybackRateL();
}

void CMMAMIDITempoControl::StateChanged(TInt aState)
{
    DEBUG_INT("CMMAMIDITempoControl:: StateChanged, state = %d", aState);

    // If tempo was set when the player was in REALIZED state, set the tempo
    // now when the player has been prefetched.
    if ((aState == CMMAPlayer::EPrefetched) &&
            (iTempo != KMMAMIDIDefaultTempoInMicroBeats))
    {
        CMidiClientUtility* midi = iPlayer->MidiClient();
        TRAPD(err, midi->SetTempoL(iTempo));

        DEBUG_INT("CMMAMIDITempoControl:: StateChanged, err = %d", err);

        if (err != KErrNone)
        {
            iPlayer->PostStringEvent(CMMAPlayerEvent::EError,
                                     KMMAMidiTempoStateChangedError);
        }
    }
    else if (aState == CMMAPlayer::ERealized)
    {
        // If the player was deallocated, set the tempo to the default value.
        iTempo = KMMAMIDIDefaultTempoInMicroBeats;
    }
}
void CMMAMIDITempoControl::MmcuoStateChanged(TMidiState /*aOldState*/,
        TMidiState /*aNewState*/,
        const TTimeIntervalMicroSeconds& /*aTime*/,
        TInt /*aError*/)
{
}

void CMMAMIDITempoControl::MmcuoTempoChanged(TInt aMicroBeatsPerMinute)
{
    DEBUG("CMMAMIDITempoControl:: MmcuoTempoChanged");

    iTempo = aMicroBeatsPerMinute;
}

void CMMAMIDITempoControl::MmcuoVolumeChanged(TInt /*aChannel*/,TReal32 /*aVolumeInDecibels*/)
{
}

void CMMAMIDITempoControl::MmcuoMuteChanged(TInt /*aChannel*/,TBool /*aMuted*/)
{
}

void CMMAMIDITempoControl::MmcuoSyncUpdate(const TTimeIntervalMicroSeconds& /*aMicroSeconds*/,TInt64 /*aMicroBeats*/)
{
}

void CMMAMIDITempoControl::MmcuoMetaDataEntryFound(const TInt /*aMetaDataEntryId*/,const TTimeIntervalMicroSeconds& /*aPosition*/)
{
}

void CMMAMIDITempoControl::MmcuoMipMessageReceived(const RArray<TMipMessageEntry>& /*aMessage*/)
{
}

void CMMAMIDITempoControl::MmcuoPolyphonyChanged(TInt /*aNewPolyphony*/)
{
}

void CMMAMIDITempoControl::MmcuoInstrumentChanged(TInt /*aChannel*/,TInt /*aBankId*/,TInt /*aInstrumentId*/)
{
}
//  END OF FILE