/*
* Copyright (c) 2010 Ixonos Plc.
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the "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:
* Ixonos Plc
*
* Description:  
*
*/


/* Copyright (c) 2003 Nokia. All rights reserved. */

#include "AudClip.h"
#include "AudPanic.h"

#include "AudClipInfo.h"
#include "AudSong.h"
#include "ProcTools.h"

    
CAudClip* CAudClip::NewL(CAudSong* aSong, const TDesC& aFileName,
        TTimeIntervalMicroSeconds aStartTime,                            
        MAudClipInfoObserver& aObserver, TInt aTrackIndex) 
    {
    
    CAudClip* self = new (ELeave) CAudClip(aSong);
    CleanupStack::PushL(self);
    self->ConstructL(aFileName, aStartTime, aObserver, aTrackIndex);
    CleanupStack::Pop(self);
    return self;
    
    }
    
CAudClip* CAudClip::NewL(CAudSong* aSong, RFile* aFileHandle,
        TTimeIntervalMicroSeconds aStartTime,                            
        MAudClipInfoObserver& aObserver, TInt aTrackIndex) 
    {
    
    CAudClip* self = new (ELeave) CAudClip(aSong);
    CleanupStack::PushL(self);
    self->ConstructL(aFileHandle, aStartTime, aObserver, aTrackIndex);
    CleanupStack::Pop(self);
    return self;
    
    }


CAudClip::CAudClip(CAudSong* aSong) : iSong(aSong), iMute(EFalse), iNormalize(EFalse), 
iPriority(KAudClipPriorityNormal) 
    {
    
    }

EXPORT_C CAudClipInfo* CAudClip::Info() const 
    {

    return iInfo;
    }

EXPORT_C TBool CAudClip::Normalizing() const 
    {

    return iNormalize;
    }

EXPORT_C TAudDynamicLevelMark CAudClip::DynamicLevelMark(TInt aIndex) const 
    {

    return *iDynamicLevelMarkArray[aIndex];
    }
    
EXPORT_C TInt CAudClip::DynamicLevelMarkCount() const 
    {

    return iDynamicLevelMarkArray.Count();
    }
EXPORT_C TBool CAudClip::Muting() const
    {
    return iMute;
    }

EXPORT_C void CAudClip::SetStartTime(TTimeIntervalMicroSeconds aStartTime) 
    {

    if (iStartTime.Int64() != aStartTime.Int64()-iCutInTime.Int64()) 
        {
        iStartTime = aStartTime.Int64()-iCutInTime.Int64();
        }
        

    TInt clipIndexOnSong = iSong->FindClipIndexOnSong(this);
    TInt newIndex = 0;
    TBool found = EFalse;
    for (newIndex = 0 ; newIndex < iSong->ClipCount(KAllTrackIndices); newIndex++) 
        {
        if (iSong->iClipArray[newIndex]->StartTime() > aStartTime) 
            {
            found = ETrue;
            break;
            }
        }
    if (!found) 
        {
        newIndex = iSong->ClipCount(KAllTrackIndices);
        }

    // the order is the same
    if (newIndex == clipIndexOnSong || newIndex == clipIndexOnSong+1) 
        {
        
        iSong->FireClipTimingsChanged(iSong, this);
        }
    else 
        {


        TInt oldIndexOnTrack = iIndex;
        iSong->UpdateClipArray();
        iSong->UpdateClipIndexes();
        TInt newIndexOnTrack = iIndex;

        if (oldIndexOnTrack != newIndexOnTrack) 
            {
            iSong->FireClipIndicesChanged(iSong, oldIndexOnTrack, newIndexOnTrack, iTrackIndex);
            }
        else 
            {
            iSong->FireClipTimingsChanged(iSong, this);
            }

        }

    }




EXPORT_C TTimeIntervalMicroSeconds CAudClip::StartTime() const 
    {

    return iStartTime.Int64()+iCutInTime.Int64();
    }



TInt32 CAudClip::StartTimeMilliSeconds() const 
    {

    return ProcTools::MilliSeconds(iStartTime);
    
    }

EXPORT_C TTimeIntervalMicroSeconds CAudClip::EndTime() const
    {
    return TTimeIntervalMicroSeconds(iStartTime.Int64()+iCutOutTime.Int64());

    }


EXPORT_C TTimeIntervalMicroSeconds CAudClip::EditedDuration() const
    {
    TTimeIntervalMicroSeconds edDur(iCutOutTime.Int64()-iCutInTime.Int64());
    return edDur;

    }

EXPORT_C TInt CAudClip::Priority() const
    {
    return iPriority;
    
    }


EXPORT_C TInt CAudClip::IndexOnTrack() const 
    {

    return iIndex;
    }



EXPORT_C TInt CAudClip::TrackIndex() const 
    {

    return iTrackIndex;
    }


EXPORT_C TTimeIntervalMicroSeconds CAudClip::CutInTime() const 
    {
    
    return iCutInTime;
    }
    

TInt32 CAudClip::CutInTimeMilliSeconds() const 
    {

    return ProcTools::MilliSeconds(iCutInTime);
    
    }

EXPORT_C void CAudClip::SetCutInTime(TTimeIntervalMicroSeconds aCutInTime) 
    {

    TInt64 oldCutIn = iCutInTime.Int64();
    TInt64 cutDif = aCutInTime.Int64() - oldCutIn;  

    iCutInTime = aCutInTime;
    iStartTime = (TTimeIntervalMicroSeconds)(iStartTime.Int64()-cutDif);
    iSong->FireClipTimingsChanged(iSong, this);
    }
    
EXPORT_C TTimeIntervalMicroSeconds CAudClip::CutOutTime() const 
    {

    return iCutOutTime;
    }

TInt32 CAudClip::CutOutTimeMilliSeconds() const 
    {

    return ProcTools::MilliSeconds(iCutOutTime);
    

    }
    
EXPORT_C void CAudClip::SetCutOutTime(TTimeIntervalMicroSeconds aCutOutTime) 
    {

    iCutOutTime = aCutOutTime;
    iSong->FireClipTimingsChanged(iSong, this);
    }




EXPORT_C TBool CAudClip::SetPriority(TInt aPriority)

    {
    if (aPriority < 0) return EFalse;

    iPriority = aPriority;
    return ETrue;

    }


EXPORT_C TInt CAudClip::InsertDynamicLevelMarkL(const TAudDynamicLevelMark& aMark) 
    {

    if (aMark.iTime < TTimeIntervalMicroSeconds(0)) 
        {
        TAudPanic::Panic(TAudPanic::EIllegalDynamicLevelMark);
        }

    TAudDynamicLevelMark* newMark = new (ELeave) TAudDynamicLevelMark(aMark);
    
    TBool added = EFalse;
    TInt err = KErrNone;

    // insert marks so that they are always sorted by time
    TInt index = 0;
    for (index = 0 ; index < iDynamicLevelMarkArray.Count() ; index++) 
        {
        if (iDynamicLevelMarkArray[index]->iTime == newMark->iTime) 
            {
            // replace the level
            TAudDynamicLevelMark* oldMark = iDynamicLevelMarkArray[index];
            iDynamicLevelMarkArray.Remove(index);
            delete oldMark;
            err = iDynamicLevelMarkArray.Insert(newMark, index);
            added = ETrue;
            break;
            }
        else if (iDynamicLevelMarkArray[index]->iTime > newMark->iTime) 
            {
            err = iDynamicLevelMarkArray.Insert(newMark, index);
            added = ETrue;
            break;
            }
        }
    if (!added) 
        {
        index = iDynamicLevelMarkArray.Count();
        err = iDynamicLevelMarkArray.Insert(newMark, index);
        }
    if (err != KErrNone) 
        {
        User::Leave(err);
        }

    iSong->FireDynamicLevelMarkInserted(*this, *newMark, index);
    return index;


    }
    
EXPORT_C TBool CAudClip::RemoveDynamicLevelMark(TInt aIndex) 
    {

    if (aIndex > iDynamicLevelMarkArray.Count() || aIndex < 0) 
        {
        TAudPanic::Panic(TAudPanic::EAudioClipIllegalIndex);
        }
    
    TAudDynamicLevelMark* mark = iDynamicLevelMarkArray[aIndex];
    
    iDynamicLevelMarkArray.Remove(aIndex);
    delete mark;
    
    iSong->FireDynamicLevelMarkRemoved(*this, aIndex);
    return ETrue;
    }
    
EXPORT_C void CAudClip::SetMuting(TBool aMuted)
    {
    
    iMute = aMuted;
    
    }

EXPORT_C void CAudClip::SetNormalizing(TBool aNormalizing) 
    {
    
    iNormalize = aNormalizing;    

    }

EXPORT_C void CAudClip::Reset(TBool aNotify) 
    {

    TInt a = 0;

    for (a = 0 ; a < iDynamicLevelMarkArray.Count() ; a++) 
        {
        delete iDynamicLevelMarkArray[a];
        }
    iDynamicLevelMarkArray.Reset();
    iCutInTime = 0;
    
    if (iInfo != 0)
        {
        iCutOutTime = iInfo->Properties().iDuration;
        }

    if (aNotify) 
        {
        iSong->FireClipReseted(*this);
        }

    }


EXPORT_C void CAudClip::SetVolumeGain(TInt aVolumeGain)
    {
    iVolumeGain = aVolumeGain;
    }

EXPORT_C TInt CAudClip::GetVolumeGain()
    {
    return iVolumeGain;
    }

/*
EXPORT_C TBool CAudClip::operator<(const CAudClip &c2) const {

    return (this->iStartTime < c2.StartTime());

}


EXPORT_C TBool CAudClip::operator>(const CAudClip &c2) const {

    return (this->iStartTime > c2.StartTime());

}

EXPORT_C TBool CAudClip::operator==(const CAudClip &c2) const {

    return (this->iStartTime == c2.StartTime());

}
*/
TInt CAudClip::Compare(const CAudClip& c1, const CAudClip& c2) 
    {

    if (c1.iStartTime > c2.iStartTime) 
        {
        return 1;
        }
    else if (c1.iStartTime < c2.iStartTime) 
        {
        return -1;
        }
    else 
        {
        return 0;
        }
    }



void CAudClip::ConstructL(const TDesC& aFileName,
                          TTimeIntervalMicroSeconds aStartTime,
                          MAudClipInfoObserver& aObserver, TInt aTrackIndex) 
    {
    
    __ASSERT_ALWAYS(aStartTime >= TInt64(0), 
        TAudPanic::Panic(TAudPanic::EAudioClipIllegalStartTime));
    iStartTime = aStartTime;
    iTrackIndex = aTrackIndex;
    
    iInfo = CAudClipInfo::NewL(aFileName, aObserver);
    
    }
    
void CAudClip::ConstructL(RFile* aFileHandle,
                          TTimeIntervalMicroSeconds aStartTime,
                          MAudClipInfoObserver& aObserver, TInt aTrackIndex) 
    {
    
    __ASSERT_ALWAYS(aStartTime >= TInt64(0), 
        TAudPanic::Panic(TAudPanic::EAudioClipIllegalStartTime));
    iStartTime = aStartTime;
    iTrackIndex = aTrackIndex;
    
    iInfo = CAudClipInfo::NewL(aFileHandle, aObserver);
    
    }


CAudClip::~CAudClip() 
    {

    Reset(EFalse);
    if (iInfo != 0)
        {
        delete iInfo;
        iInfo = 0;
        }
    
    }