/*
* Copyright (c) 2006-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:      Implementation of base DLNA profile resolver class for audio 
*                files.
*
*/






// system includes
// NONE

// includes
#include <mdaaudiosampleeditor.h> // CMdaAudioConvertUtility
#include <badesca.h> // CDesC16ArrayFlat
#include "upnpaudiosolverbase.h"

_LIT( KComponentLogfile, "dlnaprofiler.txt");
#include "upnplog.h"

// constants
_LIT( KTargetAudioFile, "c:\\unnecessary.txt" );

// audio mime types
_LIT8( KAudioMpeg, "audio/mpeg" );
_LIT8( KAudio3gpp, "audio/3gpp" );
_LIT8( KAudioMp4, "audio/mp4" );
_LIT8( KAudioL16, "audio/L16" );
_LIT8( KAudioAdts, "audio/vnd.dlna.adts" );
_LIT8( KAudioWma, "audio/x-ms-wma" );

// audio profiles
_LIT( KLpcm, "LPCM" );
_LIT( KMp3, "MP3" );
_LIT( KAac_iso, "AAC_ISO" );
_LIT( KAac_iso_320, "AAC_ISO_320" );
_LIT( KAac_mult5_iso, "AAC_MULT5_ISO" );
_LIT( KWmabase, "WMABASE" );
_LIT( KWmafull, "WMAFULL" );
_LIT( KWmapro, "WMAPRO" );

const TInt KAac_iso_320_max_bitrate = 320000;
const TInt KAac_iso_max_samplerate = 48000;
const TInt KAac_iso_max_bitrate = 576000;

const TInt KWmabase_max_bitrate = 192999;
const TInt KWmafull_max_bitrate = 385000;
const TInt KWmapro_max_bitrate = 1500000;

const TInt KWmabase_max_samplerate = 48000;
const TInt KWmafull_max_samplerate = 48000;
const TInt KWmapro_max_samplerate = 96000;

const TInt KTwo_Channels = 2;
const TInt KSix_Channels = 6;
const TInt KEight_Channels = 8;

// ======== LOCAL FUNCTIONS ========
// NONE

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

// --------------------------------------------------------------------------
// CUpnpAudioSolverBase C++ constructor
// --------------------------------------------------------------------------
//
CUpnpAudioSolverBase::CUpnpAudioSolverBase()
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase Constructor" );
    }

// --------------------------------------------------------------------------
// CUpnpAudioSolverBase::ConstructL
// --------------------------------------------------------------------------
//
void CUpnpAudioSolverBase::ConstructL()
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::ConstructL" );
    iWait = new( ELeave ) CActiveSchedulerWait;
    }


// --------------------------------------------------------------------------
// CUpnpAudioSolverBase::NewL
// --------------------------------------------------------------------------
//
CUpnpAudioSolverBase* CUpnpAudioSolverBase::NewL()
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::NewL" );
    CUpnpAudioSolverBase* self = CUpnpAudioSolverBase::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


// --------------------------------------------------------------------------
// CUpnpAudioSolverBase::NewLC
// --------------------------------------------------------------------------
//
CUpnpAudioSolverBase* CUpnpAudioSolverBase::NewLC()
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::NewLC" );
    CUpnpAudioSolverBase* self = new( ELeave ) CUpnpAudioSolverBase;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// --------------------------------------------------------------------------
// CUpnpAudioSolverBase destructor
// --------------------------------------------------------------------------
//
CUpnpAudioSolverBase::~CUpnpAudioSolverBase()
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::Destructor" );
    delete iAudioconverter;
    delete iWait;
    }

// --------------------------------------------------------------------------
// From class MUpnpProfiler.
// SupportedProfilesL returns DLNA profiles that are currently supported.
// --------------------------------------------------------------------------
//
TInt CUpnpAudioSolverBase::SupportedProfilesL( 
                                          CDesC16ArrayFlat* aProfiles ) const
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::\
SupportedProfilesL" );
    TInt retval = KErrNone;
    
    if ( !aProfiles ) 
        {
        // Invalid parameter
        retval = KErrArgument;
        }
    else 
        {
        // append all new profiles recognized by this solver
        // do not allow duplicates
        TInt tempPos = KErrNotFound;
        
        if ( aProfiles->Find( KLpcm(), tempPos, ECmpFolded ) ) 
            {
            aProfiles->AppendL( KLpcm() );
            }
        if ( aProfiles->Find( KMp3(), tempPos, ECmpFolded ) ) 
            {
            aProfiles->AppendL( KMp3() );
            }
        if ( aProfiles->Find( KAac_iso(), tempPos, ECmpFolded ) ) 
            {
            aProfiles->AppendL( KAac_iso() );
            }
        if ( aProfiles->Find( KAac_iso_320(), tempPos, ECmpFolded ) ) 
            {
            aProfiles->AppendL( KAac_iso_320() );
            }
        if ( aProfiles->Find( KAac_mult5_iso(), tempPos, ECmpFolded ) ) 
            {
            aProfiles->AppendL( KAac_mult5_iso() );
            }
        if ( aProfiles->Find( KWmabase(), tempPos, ECmpFolded ) ) 
            {
            aProfiles->AppendL( KWmabase() );
            }
        if ( aProfiles->Find( KWmafull(), tempPos, ECmpFolded ) ) 
            {
            aProfiles->AppendL( KWmafull() );
            }
        if ( aProfiles->Find( KWmapro(), tempPos, ECmpFolded ) ) 
            {
            aProfiles->AppendL( KWmapro() );
            }
        }
        
    return retval;
    }
    
// --------------------------------------------------------------------------
// From class MUpnpProfiler.
// ProfileForFileL is for resolving a DLNA profile of a given file. Besides 
// of file name, also mime type of the file is passed as a parameter in 
// order to avoid re-opening the file.
// --------------------------------------------------------------------------
//
HBufC* CUpnpAudioSolverBase::ProfileForFileL( const TDesC& aFilename,
                                              const TDesC8& aMimetype, 
                                              RFile& /*aFile*/ ) 
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::ProfileForFileL" );
    HBufC* retval = NULL;
    
    if ( aMimetype.Compare( KAudioMpeg() ) == 0 ) 
        {
        // Note that MP3X profile is currently not supported.
        retval = HBufC::NewL( KMp3().Length() );
        retval->Des().Append( KMp3() );
        }
    else if ( aMimetype.Compare( KAudioMp4() ) == 0 ) 
        {
        // obtain bitrate and channel count information from the file
        GetAudioFileInformationL( aFilename );

        retval = DetermineMp4ProfileL();
        }
    else if ( aMimetype.Compare( KAudio3gpp() ) == 0 ) 
        {
        // obtain bitrate and channel count information from the file
        GetAudioFileInformationL( aFilename );
        
        retval = Determine3GppProfileL();
        }
    else if ( aMimetype.Left( KAudioL16().Length() ).Compare( 
                                                     KAudioL16() ) == 0 ) 
        {
        retval = HBufC::NewL( KLpcm().Length() );
        retval->Des().Append( KLpcm() );
        }
    else if ( aMimetype.Compare( KAudioWma() ) == 0 ) 
        {
        // obtain bitrate and channel count information from the file
        GetAudioFileInformationL( aFilename );

        retval = DetermineWmaProfileL();
        }
    else if ( aMimetype.Compare( KAudioAdts() ) == 0 ) 
        {
        // no audio/vnd.dlna.adts profiles currently supported
        // obtain bitrate and channel count information from the file
        //GetAudioFileInformationL( aFilename );
        //retval = DetermineAdtsProfileL();
        }
        
    return retval;
    }

// --------------------------------------------------------------------------
// From class MMdaObjectStateChangeObserver.
// MoscoStateChangeEvent callback is called after a call to 
// CMdaAudioConvertUtility::OpenL has completed.
// --------------------------------------------------------------------------
//
void CUpnpAudioSolverBase::MoscoStateChangeEvent( CBase */*aObject*/, 
                                                  TInt /*aPreviousState*/, 
                                                  TInt /*aCurrentState*/, 
                                                  TInt aErrorCode ) 
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::\
MoscoStateChangeEvent" );
    if( KErrNone == aErrorCode )
        {
            // get bit rate and channel count of the file. Trap because this 
            // method may not leave. TRAP_IGNORE because there is nothing we
            // can do in case of leave.
            TRAP_IGNORE( iBitrate = iAudioconverter->SourceBitRateL() );
            TRAP_IGNORE( iChannelCount = 
                            iAudioconverter->SourceNumberOfChannelsL() );
            TRAP_IGNORE( iSampleRate = 
                            iAudioconverter->SourceSampleRateL() );
        }
        
    // continue execution in ProfileForFileL-method by stopping 
    // ActiveSchedulerWait
    iWait->AsyncStop();
    }

// --------------------------------------------------------------------------
// GetAudioFileInformationL is for resolving audio file attributes by using 
// CMdaAudioConvertUtility. 
// --------------------------------------------------------------------------
//
TInt CUpnpAudioSolverBase::GetAudioFileInformationL( const TDesC& aFilename )
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::\
GetAudioFileInformationL" );
    TInt retval = KErrNone;
    
    // create audioconverter if it does not exist
    if ( !iAudioconverter ) 
        {
        iAudioconverter = CMdaAudioConvertUtility::NewL( *this );
        }
    
    // Create iWait if it does not exist. Create it here rather than after 
    // OpenL-call so that there will be no problems if somehow OpenL calls 
    // MoscoStateChangeEvent-callback before iWait is created and started.
    if ( !iWait ) 
        {
        iWait = new( ELeave ) CActiveSchedulerWait;
        }

    // Open file specified in aFilename. This is an asynchronic operation. 
    // Calls MoscoStateChangeEvent callback after completed.
    TMdaFileClipLocation sinkFile( KTargetAudioFile() );
    TMdaRawAudioClipFormat  sinkformat;
    iAudioconverter->OpenL( aFilename, &sinkFile, &sinkformat );

    // start CActiveSchedulerWait which is completed in MoscoStateChangeEvent
    iWait->Start();

    // openL + MoscoStateChangeEvent callback executed now
    delete iAudioconverter;
    iAudioconverter = NULL;
    delete iWait;
    iWait = NULL;

    // delete temporary file
    RFs fs;
    User::LeaveIfError( fs.Connect() );
    CleanupClosePushL( fs );
    User::LeaveIfError( fs.Delete( KTargetAudioFile() ) );
    CleanupStack::PopAndDestroy( &fs );
    
    return retval;
    }

// --------------------------------------------------------------------------
// Determine3GppProfileL is for determining profile for 3gpp audio files
// --------------------------------------------------------------------------
//
HBufC* CUpnpAudioSolverBase::Determine3GppProfileL() const
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::\
Determine3GppProfileL" );
    HBufC* retval = NULL;
    
    if ( iBitrate <= KAac_iso_320_max_bitrate && 
         iSampleRate <= KAac_iso_max_samplerate && 
         iChannelCount <= KTwo_Channels ) 
        {
        retval = HBufC::NewL( KAac_iso_320().Length() );
        retval->Des().Append( KAac_iso_320() );
        }
    else if ( iSampleRate <= KAac_iso_max_samplerate && 
              iChannelCount <= KTwo_Channels )
        {
        retval = HBufC::NewL( KAac_iso().Length() );
        retval->Des().Append( KAac_iso() ); 
        }
    else if ( iSampleRate <= KAac_iso_max_samplerate && 
              iChannelCount <= KSix_Channels )
        {
        retval = HBufC::NewL( KAac_mult5_iso().Length() );
        retval->Des().Append( KAac_mult5_iso() ); 
        }    
    
    return retval;
    }



// --------------------------------------------------------------------------
// DetermineWmaProfileL is for determining profile for wma files
// --------------------------------------------------------------------------
//
HBufC* CUpnpAudioSolverBase::DetermineWmaProfileL() const
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::\
DetermineWmaProfileL" );
    HBufC* retval = NULL;

    if ( iBitrate <= KWmabase_max_bitrate && 
         iSampleRate <= KWmabase_max_samplerate && 
         iChannelCount <= KTwo_Channels )
        {
        retval = HBufC::NewL( KWmabase().Length() );
        retval->Des().Append( KWmabase() );   
        }
    else if ( iBitrate <= KWmafull_max_bitrate && 
              iSampleRate <= KWmafull_max_samplerate && 
              iChannelCount <= KTwo_Channels ) 
        {
        retval = HBufC::NewL( KWmafull().Length() );
        retval->Des().Append( KWmafull() );
        }
    else if ( iBitrate <= KWmapro_max_bitrate && 
              iSampleRate <= KWmapro_max_samplerate && 
              iChannelCount <= KEight_Channels ) 
        {
        retval = HBufC::NewL( KWmapro().Length() );
        retval->Des().Append( KWmapro() );
        }
        
    return retval;
}

// --------------------------------------------------------------------------
// DetermineMp4ProfileL is for determining profile for mp4 audio files
// --------------------------------------------------------------------------
//
HBufC* CUpnpAudioSolverBase::DetermineMp4ProfileL() const
    {
    __LOG( "[UPnPDlnaProfiler] CUpnpAudioSolverBase::\
DetermineMp4ProfileL" );
    HBufC* retval = NULL;
    
    if ( iBitrate <= KAac_iso_320_max_bitrate && 
         iChannelCount <= KTwo_Channels ) 
        {
        retval = HBufC::NewL( KAac_iso_320().Length() );
        retval->Des().Append( KAac_iso_320() );            
        }
    else if ( iBitrate <= KAac_iso_max_bitrate && 
              iChannelCount <= KTwo_Channels )
        {
        retval = HBufC::NewL( KAac_iso().Length() );
        retval->Des().Append( KAac_iso() ); 
        }
        
    return retval;
}


// end of file