/*

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

*

*/

#include "VedMovieImp.h"

#include "VedVideoClipGenerator.h"

#include "movieprocessor.h"

#include "VedVideosettings.h"

#include "VedAudiosettings.h"

#include <ecom/ecom.h>

#include "VedAudioClipInfoImp.h"

#include "AudSong.h"

#include "AudClip.h"

#include "AudClipInfo.h"

#include "Vedqualitysettingsapi.h"

#include "ctrtranscoder.h"

#include "ctrtranscoderobserver.h"

#include "vedproctimeestimate.h"

#include "vedcodecchecker.h"

#include <vedcommon.h>

const TInt KVedAudioTrackIndex = 1;

// Print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

// Near-dummy observer class for temporary transcoder instance. In practice is only used to provide input framerate

// to the transcoder

class CTrObs : public CBase, public MTRTranscoderObserver

    {

public:

    /* Constructor & destructor */

    inline CTrObs(TReal aFrameRate) : iInputFrameRate(aFrameRate) 

        {

        };

    inline ~CTrObs()

        {

        };

    // Dummy methods from MTRTranscoderObserver, just used to complete the observer class

    inline void MtroInitializeComplete(TInt /*aError*/)

        {

        };

    inline void MtroFatalError(TInt /*aError*/)

        {

        };

    inline void MtroReturnCodedBuffer(CCMRMediaBuffer* /*aBuffer*/) 

        {

        };

    // method to provide clip input framerate to transcoder

    inline void MtroSetInputFrameRate(TReal& aRate)

        {

        aRate = iInputFrameRate;

        };

    inline void MtroAsyncStopComplete()

        {

        };

    inline void MtroSuspend()

        {

        };

    inline void MtroResume()

        {

        };

private:// data

        // clip input framerate (fps)

        TReal iInputFrameRate;

    };

// -------- Local functions ---------

// Map video format mimetype to editor's internal enumeration 

static TVedVideoFormat MapVideoFormatTypes(const TText8* aVideoFormatType)

    {

    TPtrC8 mimeType(aVideoFormatType);

    TBuf8<256> string;

    string = _L8("video/3gpp");

    if ( mimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

        {

        return EVedVideoFormat3GPP;

        }

    else

        {

        string = _L8("video/mp4");

        if ( mimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

            {

            return EVedVideoFormatMP4;

            }

        }

    return EVedVideoFormatUnrecognized;

    }

// Map video codec mimetype to editor's internal enumeration 

static TVedVideoType MapVideoCodecTypes(const TText8* aVideoCodecType)

    {

    TPtrC8 mimeType(aVideoCodecType);

    TBuf8<256> string;

    string = _L8("video/H263*");

    if ( mimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

        {

        // H.263

        string = _L8("*level*");

        if ( mimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

            {

            string = _L8("*level=10");

            if ( mimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

                {

                return EVedVideoTypeH263Profile0Level10;

                }

            string = _L8("*level=45");

            if ( mimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

                {

                return EVedVideoTypeH263Profile0Level45;

                }

            }

        // no level specified => 10        

        return EVedVideoTypeH263Profile0Level10;

        }

    else

        {

        string = _L8("video/mp4v-es*");

        if ( mimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

            {

            return EVedVideoTypeMPEG4SimpleProfile;

            }

        else 

            {

            string = _L8("video/h264*");

            if ( mimeType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

                {

                return EVedVideoTypeAVCBaselineProfile;

                }

            }

        }

    return EVedVideoTypeUnrecognized;

    }

// Map editor's internal enumeration to video codec mimetype

static void MapVideoCodecTypeToMime(TVedVideoType aType, TBufC8<255>& aMimeType)

    {

    switch ( aType )

        {

        case EVedVideoTypeH263Profile0Level10:

            {

            aMimeType =  KVedMimeTypeH263BaselineProfile;

            }

            break;

        case EVedVideoTypeH263Profile0Level45:

            {

            aMimeType = KVedMimeTypeH263Level45;

            }

            break;

        default:

            {

            //EVedVideoTypeMPEG4SimpleProfile

            aMimeType = KVedMimeTypeMPEG4Visual;

            }

        }

    }

// Map audio codec fourcc to editor's internal enumeration 

static TAudType MapAudioCodecTypes(const TText8* aAudioCodecType)

    {

    TPtrC8 fourCCType(aAudioCodecType);

    TBuf8<256> string;

    string = _L8(" AMR");

    if ( fourCCType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

        {

        return EAudAMR;

        }

    else  

        {

        string = _L8(" AAC");

        if ( fourCCType.MatchF( (const TDesC8& )string ) != KErrNotFound ) 

            {

            return EAudAAC_MPEG4;

            }

        }

    return EAudTypeUnrecognized;

    }

// -------- Member functions ---------

EXPORT_C CVedMovie* CVedMovie::NewL(RFs *aFs)

    {

    PRINT(_L("CVedMovie::NewL"));

    CVedMovieImp* self = (CVedMovieImp*)NewLC(aFs);

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CVedMovie* CVedMovie::NewLC(RFs *aFs)

    {

    PRINT(_L("CVedMovie::NewLC"));

    CVedMovieImp* self = new (ELeave) CVedMovieImp(aFs);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CVedMovieImp::CVedMovieImp(RFs *aFs)

        : iFs(aFs), 

          iVideoClipArray(8), // Initial size of video clip array is 8

          iAudioClipInfoArray(8), // Initial size of audio clip array is 8

          iObserverArray(4), // Initial size of observer array is 4

          iStartTransitionEffect(EVedStartTransitionEffectNone),

          iEndTransitionEffect(EVedEndTransitionEffectNone),

          iQuality(EQualityAutomatic),

          iNotifyObserver(ETrue),

          iMovieProcessingObserver(0)

    {

    }

void CVedMovieImp::ConstructL()

    {

    iAudSong = CAudSong::NewL(iFs);

    iAudSong->RegisterSongObserverL(this);

    iAddOperation = CVedMovieAddClipOperation::NewL(this);

    iCodecChecker = CVedCodecChecker::NewL();

    iProcessor = CMovieProcessor::NewL();

    PRINT((_L("CVedMovie::ConstructL() CVideoQualitySelector in use")));

    iQualitySelector = CVideoQualitySelector::NewL();

    CalculatePropertiesL();

    }

CVedMovieImp::~CVedMovieImp()

    {

    DoReset();

    iObserverArray.Reset();

    delete iAddOperation;

    delete iCodecChecker;    

    delete iProcessor;

    delete iAudSong;

    delete iAddedVideoClipFilename;

    delete iQualitySelector;

    REComSession::FinalClose();

    }

CVedMovie::TVedMovieQuality CVedMovieImp::Quality() const

    {

    return iQuality;

    }

void CVedMovieImp::SetQuality(TVedMovieQuality aQuality)

    {

    __ASSERT_ALWAYS(aQuality >= EQualityAutomatic && aQuality < EQualityLast,

        TVedPanic::Panic(TVedPanic::EMovieIllegalQuality));

    if (aQuality != iQuality) 

        {

        iOutputParamsSet = EFalse;

        TVedMovieQuality prevQuality = iQuality;

        iQuality = aQuality;

        TRAPD(err,CalculatePropertiesL());//should not leave with current implementation, but try to handle it anyway

        if ( err == KErrNone )

            {

            // successful

            FireMovieQualityChanged(this);

            }

        else

            {

            // setting was not successful, use the previous value

            iQuality = prevQuality;

            TRAP(err,CalculatePropertiesL());// previous should always succee

            }

        }

    }

TVedVideoFormat CVedMovieImp::Format() const

    {

    return iFormat;

    }

TVedVideoType CVedMovieImp::VideoType() const

    {

    return iVideoType;

    }

TSize CVedMovieImp::Resolution() const

    {

    return iResolution;

    }

TInt CVedMovieImp::MaximumFramerate() const

    {

    return iMaximumFramerate;

    }

TVedAudioType CVedMovieImp::AudioType() const

    {

    TAudType audioType = iAudSong->OutputFileProperties().iAudioType;

    TVedAudioType vedAudioType = EVedAudioTypeUnrecognized;

    if (iAudSong->ClipCount(KAllTrackIndices) == 0)

        {

        vedAudioType = EVedAudioTypeNoAudio;

        }

    else if (audioType == EAudAMR)

        {

        vedAudioType = EVedAudioTypeAMR;

        }

    else if (audioType == EAudAAC_MPEG4 )

        {

        vedAudioType = EVedAudioTypeAAC_LC;

        }

	else if (audioType == EAudNoAudio)

		{

		vedAudioType = EVedAudioTypeNoAudio;

		}

    return vedAudioType;

    }

TInt CVedMovieImp::AudioSamplingRate() const

    {

    return iAudSong->OutputFileProperties().iSamplingRate;

    }

TVedAudioChannelMode CVedMovieImp::AudioChannelMode() const

    {

    TVedAudioChannelMode vedChannelMode = EVedAudioChannelModeUnrecognized;

    if (iAudSong->OutputFileProperties().iChannelMode == EAudStereo)

        {

        vedChannelMode = EVedAudioChannelModeStereo;

        }

    else if (iAudSong->OutputFileProperties().iChannelMode == EAudSingleChannel)

        {

        vedChannelMode = EVedAudioChannelModeSingleChannel;

        }

    else if (iAudSong->OutputFileProperties().iChannelMode == EAudDualChannel)

        {

        vedChannelMode = EVedAudioChannelModeDualChannel;

        }

    return vedChannelMode;    

    }

TVedBitrateMode CVedMovieImp::AudioBitrateMode() const

    {

    TVedBitrateMode vedBitrateMode = EVedBitrateModeUnrecognized;

    switch(iAudSong->OutputFileProperties().iBitrateMode) 

        {

    case EAudConstant:

        vedBitrateMode = EVedBitrateModeConstant;

        break;

    case EAudVariable:

        vedBitrateMode = EVedBitrateModeVariable;

        break;

    default:

        TVedPanic::Panic(TVedPanic::EInternal);

        }

    return vedBitrateMode;

    }

TInt CVedMovieImp::AudioBitrate() const

    {

    return iAudSong->OutputFileProperties().iBitrate;

    }

TInt CVedMovieImp::VideoBitrate() const

    {

    // restricted bitrate: forces transcoding of video content to this bitrate

    return iVideoRestrictedBitrate;

    }

TInt CVedMovieImp::VideoStandardBitrate() const

    {

    // the default bitrate to be used when encoding new content. This can be actually lower than the standard limit

    // but it is not restricted bitrate that would trigger transcoding to happen

    return iVideoStandardBitrate;

    }

TReal CVedMovieImp::VideoFrameRate() const

    {

    return iVideoFrameRate;

    }

// This must not be called for 3gp clips that should always have AMR audio

// returns ETrue if aAudioProperties contain settings found in input (can be modified by this method)

// and EFalse if client should decide what to do with them

TBool CVedMovieImp::MatchAudioPropertiesWithInput( TAudFileProperties& aAudioProperties )

    {

    // If there are no audio clips

    if (iAudSong->ClipCount(KAllTrackIndices) == 0)

        {

        return ETrue;

        }

    // Go through the audio clips and select the best one

    TAudFileProperties prop;

    TAudFileProperties highestProp;

    TBool highestPropFound = EFalse;

    for (TInt a = 0; a < iAudSong->ClipCount(KAllTrackIndices); a++)

        {

        CAudClip* clip = iAudSong->Clip(a, KAllTrackIndices);        

        prop = clip->Info()->Properties();

        if ( ( prop.iChannelMode == aAudioProperties.iChannelMode ) &&

             ( prop.iSamplingRate == aAudioProperties.iSamplingRate ) )

            {

            // there is a match => keep the properties

            PRINT((_L("CVedMovie::MatchAudioPropertiesWithInput() found preferred set from input, sampling rate & channels %d & %d"), prop.iSamplingRate, prop.iChannelMode));

            return ETrue;

            }

        else

            {

            // need to stay within limits given by aAudioProperties (it has the highest preferred mode)

            if ( ( prop.iAudioType == aAudioProperties.iAudioType ) &&

                 ( prop.iSamplingRate <= aAudioProperties.iSamplingRate ) )

                {

                // take the highest channelmode & sampling rate from input. 

                if ( !highestPropFound || 

                    ( (prop.iSamplingRate > highestProp.iSamplingRate) ||

                      ( (prop.iSamplingRate == highestProp.iSamplingRate) && (prop.iChannelMode > highestProp.iChannelMode) ) ) )

                    {

                    PRINT((_L("CVedMovie::MatchAudioPropertiesWithInput() found new highest prop from input, sampling rate & channels %d & %d"), prop.iSamplingRate, prop.iChannelMode));

                    highestProp.iAudioType = prop.iAudioType;

                    highestProp.iChannelMode = prop.iChannelMode;

                    highestProp.iSamplingRate = prop.iSamplingRate;

                    highestPropFound = ETrue;

                    }

                }

            }

        }

    // if we come here, there was no exact match found. Use the best one, if found

    if ( highestPropFound )

        {

        // take the sampling rate and channel mode from inProp. Currently we support only 16k and 48k output, but this should be changed

        // once we know what we need to support; but requires synchronization with audio editor engine

        if ( iAudSong->AreOutputPropertiesSupported(highestProp))

            {

            PRINT((_L("CVedMovie::MatchAudioPropertiesWithInput() selected audio parameters, sampling rate & channels %d & %d"), highestProp.iSamplingRate, highestProp.iChannelMode));

            aAudioProperties.iChannelMode = highestProp.iChannelMode;

            aAudioProperties.iSamplingRate = highestProp.iSamplingRate;

            aAudioProperties.iBitrate = KAudBitRateDefault; //use default since we don't know the bitrate of the input.

            return ETrue;

            }

        else

            {

            // We have some AAC in the input but it is not any of our supported sampling rates. 

            // The aAudioProperties may have 48k here but since we don't have such high input, better to use 16k in output

            PRINT((_L("CVedMovie::MatchAudioPropertiesWithInput() no good match with input")));

            return EFalse;

            }

        }

    else

        {

        // Not even a close match

        PRINT((_L("CVedMovie::MatchAudioPropertiesWithInput() not even a close match with input")));

        return EFalse;

        }

    }

// Set video codec mimetype member variable, and also max values that level defines (e.g. max framerate; actual values are taken from quality set)

void CVedMovieImp::SetVideoCodecMimeType(const TText8* aVideoCodecType)

    {

    TPtrC8 mimeType(aVideoCodecType);

    if ( mimeType.MatchF( KVedMimeTypeH263 ) != KErrNotFound ) 

        {

        // H.263 baseline

        iVideoCodecMimeType.Set(KVedMimeTypeH263BaselineProfile);

        iMaximumFramerate = 15;

        }

    else if ( mimeType.MatchF( KVedMimeTypeH263BaselineProfile ) != KErrNotFound ) 

        {

        // H.263 baseline

        iVideoCodecMimeType.Set(KVedMimeTypeH263BaselineProfile);

        iMaximumFramerate = 15;

        }

    else if (mimeType.MatchF( KVedMimeTypeH263Level45 ) != KErrNotFound )

        {

        // H.263 level 45

        iVideoCodecMimeType.Set(KVedMimeTypeH263Level45);

        iMaximumFramerate = 15;