/*
* Copyright (c) 2008 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:  Maintains the set of supported codecs
*
*/

#include <e32base.h>

#include <eikenv.h>
#include <f32file.h>


#include "ircodecmanager.h"
#include "irdebug.h"

// ---------------------------------------------------------------------------
// CIRCodecManager::NewL
// ---------------------------------------------------------------------------
//
CIRCodecManager* CIRCodecManager::NewL()
    {
    CIRCodecManager* self = CIRCodecManager::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::NewLC
// ---------------------------------------------------------------------------
//
CIRCodecManager* CIRCodecManager::NewLC()
    {
    CIRCodecManager* self = new (ELeave) CIRCodecManager();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::CIRCodecManager
// ---------------------------------------------------------------------------
//
CIRCodecManager::CIRCodecManager()
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::~CIRCodecManager
// ---------------------------------------------------------------------------
//
CIRCodecManager::~CIRCodecManager()
    {
    iSupportedDataTypes.Reset();
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::ConstructL
// ---------------------------------------------------------------------------
//
void CIRCodecManager::ConstructL()
    {
    IRLOG_DEBUG( "CIRCodecManager::ConstructL" );
    LoadSupportedCodecsL();
    IRLOG_DEBUG( "CIRCodecManager::ConstructL - Exiting." );
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::IsSupportedCodec
// ---------------------------------------------------------------------------
//
TBool CIRCodecManager::IsSupportedCodec( TFourCC aCodec ) const
    {
    IRLOG_DEBUG( "CIRCodecManager::::IsSupportedCodec" );
    TBool supported( EFalse );
    if ( iSupportedDataTypes.Find( aCodec ) != KErrNotFound )
        {
        supported = ETrue;
        }
    IRLOG_INFO3( "CIRCodecManager::IsSupportedCodec - Returning %d for codec %d",
                  supported, aCodec.FourCC() );
    return supported;
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::InitializeComplete
// ---------------------------------------------------------------------------
//
void CIRCodecManager::InitializeComplete(TInt /* aError */)
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::ToneFinished
// ---------------------------------------------------------------------------
//
void CIRCodecManager::ToneFinished(TInt /* aError */)
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::BufferToBeFilled
// ---------------------------------------------------------------------------
//
void CIRCodecManager::BufferToBeFilled(CMMFBuffer* /* aBuffer */ )
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::PlayError
// ---------------------------------------------------------------------------
//
void CIRCodecManager::PlayError(TInt /* aError */ )
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::BufferToBeEmptied
// ---------------------------------------------------------------------------
//
void CIRCodecManager::BufferToBeEmptied(CMMFBuffer* /* aBuffer */ )
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::RecordError
// ---------------------------------------------------------------------------
//
void CIRCodecManager::RecordError(TInt /* aError */ )
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::ConvertError
// ---------------------------------------------------------------------------
//
void CIRCodecManager::ConvertError(TInt /* aError */ )
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::DeviceMessage
// ---------------------------------------------------------------------------
//
void CIRCodecManager::DeviceMessage(TUid /* aMessageType */, const TDesC8& /* aMsg */ )
    {
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::LoadSupportedCodecsL
// ---------------------------------------------------------------------------
//
void CIRCodecManager::LoadSupportedCodecsL()
    {
    IRLOG_DEBUG( "CIRCodecManager::LoadSupportedCodecsL" );
    CMMFDevSound* devSound = CMMFDevSound::NewL();
    CleanupStack::PushL( devSound );
    TMMFPrioritySettings prioritySettings;

    prioritySettings.iPriority = 0;
    prioritySettings.iPref = EMdaPriorityPreferenceNone;
    prioritySettings.iState = EMMFStatePlaying;

    devSound->GetSupportedInputDataTypesL( iSupportedDataTypes, prioritySettings );
    CleanupStack::PopAndDestroy( devSound );

    // CMMFDevSound returns also other codecs than those supported by IR.
    TInt tempCount = iSupportedDataTypes.Count();
    IRRDEBUG2("CIRCodecManager::LoadSupportedCodecsL() - codecs count = %d",tempCount);
    for ( TInt i = iSupportedDataTypes.Count() - 1; i >= 0; i-- )
        {
        if ( !VerifySupportL( iSupportedDataTypes[i] ) )
            {
            IRLOG_DEBUG2( "CIRCodecManager::LoadSupportedCodecsL - %x not supported.",
                        iSupportedDataTypes[i].FourCC() );
            iSupportedDataTypes.Remove( i );
            }
        else
            {
            IRLOG_INFO2( "CIRCodecManager::LoadSupportedCodecsL - %x supported.",
                        iSupportedDataTypes[i].FourCC() );
            }
        }

#ifdef __WINS__
    // In emulator there is typically only 16 bit PCM supported.
    if ( iSupportedDataTypes.Count() == 0 )
        {
        TFourCC codec( KMMFFourCCCodeMP3 );
        iSupportedDataTypes.Append( codec );
        }
#endif


    IRLOG_DEBUG( "CIRCodecManager::LoadSupportedCodecsL - Exiting." );
    }

// ---------------------------------------------------------------------------
// CIRCodecManager::VerifySupportL
// ---------------------------------------------------------------------------
//
TBool CIRCodecManager::VerifySupportL( TFourCC aCodec )
    {
    IRLOG_DEBUG2( "CIRCodecManager::VefifySupportL - aCodec=%x", aCodec.FourCC() );
    TInt supported( EFalse );
    switch( aCodec.FourCC() )
        {
#ifndef __SERIES60_30__
        case KMMFFourCCCodeWMA: // fall through
#endif
        case KMMFFourCCCodeAAC: // fall through
        case KMMFFourCCCodeMP3:
            supported = ETrue;
            break;
        default:
            break;
        }
    if ( supported )
        {
        // Test initialisation to see that the codec really is supported.
        CMMFDevSound* devSound = CMMFDevSound::NewL();
        CleanupStack::PushL( devSound );

        TMMFState mmfState( EMMFStatePlaying );
        TRAPD( err, devSound->InitializeL( *this, aCodec, mmfState ) );
        if ( err != KErrNone )
            {
            supported = EFalse;
            }
        CleanupStack::PopAndDestroy( devSound );
        }
    IRLOG_DEBUG( "CIRCodecManager::VefifySupportL" );
    return supported;
    }