/*
* 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:  
*
*/



#ifndef __CAUDPROCESSORIMPL_H__
#define __CAUDPROCESSORIMPL_H__

#include <e32base.h>
#include <e32math.h>
#include "AudClipInfo.h"
#include "AudCommon.h"
#include "AudSong.h"
#include "ProcInFileHandler.h"

#include "ProcFrameHandler.h"
#include "ProcWAVFrameHandler.h"




#include "ProcTools.h"


class MProcClipInfoObserver;

class CAudProcessorImpl : public CBase
    {
    
public:

    /*
    *
    * Symbian constructors and a destructor
    *
    */

    static CAudProcessorImpl* NewL();
    static CAudProcessorImpl* NewLC();

    virtual ~CAudProcessorImpl();


    /**
    * Performs all initializations needed for a song processing
    * such as output file opening
    * 
    * Can leave with one of the system wide error codes
    * related to memory allocation and file opening
    *
    * Possible panic code
    * <code>ESongProcessingOperationAlreadyRunning</code>
    *
    *
    *
    * @param aSong              song to be processed
    * @param aRawFrameSize      length of raw audio frames
    * @param aGetTimeEstimation ETrue if getting a time estimation
    *
    * @return
    *
    */
    void ProcessSongL(const CAudSong* aSong, TInt aRawFrameSize, 
                      TBool aGetTimeEstimation = EFalse);
    
    /**
    * Processes one audio frame and writes it to an output file
    *
    * Possible panic code
    * <code>ESongProcessingOperationNotRunning</code>
    *
    * @param aProgress    output parameter to indicate progress in percents
    *
    *
    * @return            ETrue if processing completed, EFalse otherwise
    *
    */
    TBool ProcessSyncPieceL(HBufC8*& aFrame, TInt& aProgress,
                                       TTimeIntervalMicroSeconds& aDuration, TBool& aRaw);



    /**
    * Gets properties of an audio file
    * 
    * Can leave with one of the error codes related to file opening
    * 
    * @param aFileName        name of the file
    * @param aFileHandle      file handle of the file to read
    * @param aProperties    pointer to audio file properties (needs to be
    *                        allocated before calling this function)
    *
    */
    void GetAudFilePropertiesL(const TDesC& aFileName, RFile* aFileHandle,
                               TAudFileProperties* aProperties);

    /**
    *
    * Gets time estimate once the time estimate has been calculated
    *
    * If time estimation has not been processed, returns 0
    *
    * @return processing time estimate in microseconds
    */
    
    TInt64 GetFinalTimeEstimate() const;
    

private:
    
    /*
    * Symbian constructor
    */
    void ConstructL();

    /*
    * Generates processing events for the output clip
    */
    void GetProcessingEventsL();

    /*
    * Calculates a gain value on a given time
    */
    TInt8 GetGainNow(const CAudClip* aClip, TInt32 aTimeMilliSeconds);

    /*
    * Stops processing
    */
    TBool StopProcessing();

    /*
    * Writes one frame of silence
    */
    TBool WriteSilenceL(HBufC8*& aFrame, TInt& aProgress,
                                       TTimeIntervalMicroSeconds& aDuration, TBool& aRaw);
    /*
    * Returns the index of the clip with highest priority 
    */
    TBool HighestInFilePriority(TInt& aFirst, TInt& aSecond);
    
    /*
    * Compares the two properties and returns true if decoding is required
    */
    TBool IsDecodingRequired(const TAudFileProperties& prop1, const TAudFileProperties& prop2);

    /*
    * C++ constructor
    */
    CAudProcessorImpl();
    
private:
    
    // Array for all the input clips
    RPointerArray<CProcInFileHandler> iInFiles;
    
    // Song
    const CAudSong* iSong;

    // frame handler for PCM operations such as mixing
    CProcWAVFrameHandler* iWAVFrameHandler;

    // time left before the end of last clip
    // (additional silence may be written after that)
    TInt32 iTimeLeft;
    
    // index of the current processing event
    TInt iCurEvent;

    // array for processing events
    RPointerArray<CProcessingEvent> iProcessingEvents;
    
    // array for storing clip indexes that are currenty written
    RArray<TInt> iClipsWritten;
    
    
    // song duration in milliseconds
    TInt iSongDurationMilliSeconds;

    // how much has already been processed
    TInt iSongProcessedMilliSeconds;

    // index of the clip that was previously processed
    TInt iLastInClip1;
    
    // a flag to indicate if we are getting a processing time estimate
    TBool iGetTimeEstimation;
    
    // timer for calculating time estimation
    TTime iTimer;
    
    // a variable for time estimate
    TInt64 iTimeEstimate;
    
    // a variable for time estimate calculation
    TReal iTimeEstimateCoefficient;
    
    TBool iSilenceStarted;
    
    };


#endif