/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "xarecordsessionimpl.h"

#include "xarecordsessioncommon.h"

_LIT8(K8WAVMIMETYPE, "audio/x-wav");

/*

 * These codec names are not part of AL. Hence we need to define names here.

 * */

_LIT(KAUDIOCODECPCM, "pcm");

_LIT(KAUDIOCODECAMR, "amr");

_LIT(KAUDIOCODECAAC, "aac");

_LIT(KCONTAINERWAVDESC, "wav container");

const TUint KRecordPosUpdatePeriod = 1000;

const TUint KMilliToHz = 1000;

const TUint KMaxNameLength = 256;

/* Local functions for callback registation */

void cbXAObjectItf(

            XAObjectItf caller,

            const void *pContext,

            XAuint32 event,

            XAresult result,

            XAuint32 param,

            void *pInterface);

void cbXARecordItf(

            XARecordItf caller,

            void *pContext,

            XAuint32 event);

void cbXAAvailableAudioInputsChanged(

            XAAudioIODeviceCapabilitiesItf caller,

            void *pContext,

            XAuint32 deviceID,

            XAint32 numInputs,

            XAboolean isNew);

XARecordSessionImpl::XARecordSessionImpl(XARecordObserver &parent)

:m_Parent(parent),

m_EOEngine(NULL),

m_MORecorder(NULL),

m_RecordItf(NULL),

m_AudioEncItf(NULL),

m_WAVMime(NULL),

m_URIName(NULL),

m_InputDeviceId(0),

m_ContainerType(0),

m_BitRate(0),

m_RateControl(0),

m_ChannelsOut(0),

m_SampleRate(0),

m_AudioIODevCapsItf(NULL),

m_AudioInputDeviceNames(NULL),

m_DefaultAudioInputDeviceNames(NULL),

m_AudioEncCapsItf(NULL)

{

    TRACE_FUNCTION_ENTRY_EXIT;

}

XARecordSessionImpl::~XARecordSessionImpl()

{

    TRACE_FUNCTION_ENTRY;

    if (m_MORecorder)

        (*m_MORecorder)->Destroy(m_MORecorder);

    if (m_EOEngine)

        (*m_EOEngine)->Destroy(m_EOEngine);

    delete m_WAVMime;

    delete m_URIName;

    m_InputDeviceIDs.Close();

    if (m_AudioInputDeviceNames)

        m_AudioInputDeviceNames->Reset();

    delete m_AudioInputDeviceNames;

    m_DefaultInputDeviceIDs.Close();

    if (m_DefaultAudioInputDeviceNames)

        m_DefaultAudioInputDeviceNames->Reset();

    delete m_DefaultAudioInputDeviceNames;

    m_EncoderIds.Close();

    m_EncoderNames.Close();

    m_ContainerNames.Close();

    m_ContainerDescs.Close();

    TRACE_FUNCTION_EXIT;

}

TInt32 XARecordSessionImpl::postConstruct()

{

    TRACE_FUNCTION_ENTRY;

    XAEngineOption engineOption[] = { (XAuint32) XA_ENGINEOPTION_THREADSAFE, (XAuint32) XA_BOOLEAN_TRUE};

    /* Create and realize Engine object */

    TRACE_LOG(_L("XARecordSessionImpl: Creating Engine..."));

    XAresult xa_result = xaCreateEngine (&m_EOEngine, 1, engineOption, 0, NULL, NULL);

    TInt returnValue = mapError(xa_result, ETrue);

    RET_ERR_IF_ERR(returnValue);

    TRACE_LOG(_L("XARecordSessionImpl: Realizing engine..."));

    xa_result = (*m_EOEngine)->Realize(m_EOEngine, XA_BOOLEAN_FALSE);

    returnValue = mapError(xa_result, ETrue);

    RET_ERR_IF_ERR(returnValue);

    TRACE_LOG(_L("XARecordSessionImpl: OMX AL Engine realized successfully"));

    XAEngineItf engineItf;

    xa_result = (*m_EOEngine)->GetInterface(m_EOEngine, XA_IID_ENGINE, (void**) &engineItf);

    returnValue = mapError(xa_result, ETrue);

    RET_ERR_IF_ERR(returnValue);

    xa_result = (*m_EOEngine)->GetInterface(m_EOEngine,

                                         XA_IID_AUDIOIODEVICECAPABILITIES,

                                         (void**) &m_AudioIODevCapsItf);

    returnValue = mapError(xa_result, ETrue);

    RET_ERR_IF_ERR(returnValue);

    xa_result = (*m_AudioIODevCapsItf)->RegisterAvailableAudioInputsChangedCallback(

                                        m_AudioIODevCapsItf,

                                        cbXAAvailableAudioInputsChanged,

                                        (void*)this);

    xa_result = (*m_EOEngine)->GetInterface(

                                 m_EOEngine,

                                 XA_IID_AUDIOENCODERCAPABILITIES,

                                 (void**) &m_AudioEncCapsItf);

    returnValue = mapError(xa_result, ETrue);

    RET_ERR_IF_ERR(returnValue);

    TRAP(returnValue, m_WAVMime = HBufC8::NewL(K8WAVMIMETYPE().Length() + 1));

    RET_ERR_IF_ERR(returnValue);

    TPtr8 ptr = m_WAVMime->Des();

    ptr = K8WAVMIMETYPE(); // copy uri name into local variable

    ptr.PtrZ(); // append zero terminator to end of URI

    m_AudioInputDeviceNames = new CDesC16ArrayFlat(2);

    if (m_AudioInputDeviceNames == NULL)

        returnValue = KErrNoMemory;

    RET_ERR_IF_ERR(returnValue);

    m_DefaultAudioInputDeviceNames = new CDesC16ArrayFlat(2);

    if (m_DefaultAudioInputDeviceNames == NULL)

        returnValue = KErrNoMemory;

    RET_ERR_IF_ERR(returnValue);

    returnValue = initContainersList();

    RET_ERR_IF_ERR(returnValue);

    returnValue = initAudioEncodersList();

    RET_ERR_IF_ERR(returnValue);

    returnValue = initAudioInputDevicesList();

    RET_ERR_IF_ERR(returnValue);

    TRACE_FUNCTION_EXIT;

    return returnValue;

}

TInt32 XARecordSessionImpl::setURI(const TDesC &aURI)

{

    TRACE_FUNCTION_ENTRY;

    /* This function will only get called when aURI is different than m_URIName

     * and only when recorder is in stopped state.

     * If the recorder object was created for a different URI (than aURI), we

     * need to tear it down here.

     */

        (*m_MORecorder)->Destroy(m_MORecorder);

        m_MORecorder = NULL;

        m_RecordItf = NULL;

    }

    delete m_URIName;

    m_URIName = NULL;

    TRAPD(returnValue, m_URIName = HBufC8::NewL(aURI.Length()+1));

    RET_ERR_IF_ERR(returnValue);

    TPtr8 uriPtr = m_URIName->Des();

     /* copy uri name into local variable */

    uriPtr.Copy(aURI);

    TRACE_FUNCTION_EXIT;

    return returnValue;

}

TInt32 XARecordSessionImpl::record()

{

    TRACE_FUNCTION_ENTRY;

    TInt32 returnValue(KErrGeneral);

    if (!m_MORecorder || !m_RecordItf) {

        TRACE_LOG(_L("XARecordSessionImpl::Record: MORecorder/RecordItf is not created"));

        returnValue = createMediaRecorderObject();

        RET_ERR_IF_ERR(returnValue);

    }

    XAuint32 state;

    XAresult xa_result = (*m_RecordItf)->GetRecordState(m_RecordItf, &state);

    returnValue = mapError(xa_result, ETrue);

    RET_ERR_IF_ERR(returnValue);

    if ((state == XA_RECORDSTATE_STOPPED)

        || (state == XA_RECORDSTATE_PAUSED)) {

        TRACE_LOG(_L("XARecordSessionImpl::Record: Setting State to Recording..."));

        xa_result = (*m_RecordItf)->SetRecordState(m_RecordItf, XA_RECORDSTATE_RECORDING);

        returnValue = mapError(xa_result, ETrue);

        RET_ERR_IF_ERR(returnValue);

        TRACE_LOG(_L("XARecordSessionImpl::Record: SetState to Recording"));

    }

    TRACE_FUNCTION_EXIT;

    return returnValue;

}

TInt32 XARecordSessionImpl::pause()

{

    TRACE_FUNCTION_ENTRY;

    TInt32 returnValue(KErrGeneral);

    if (!m_MORecorder || !m_RecordItf) {

        TRACE_LOG(_L("XARecordSessionImpl::Record: MORecorder/RecordItf is not created"));

        return returnValue;

    }

    XAuint32 state;

    XAresult xa_result = (*m_RecordItf)->GetRecordState(m_RecordItf, &state);

    returnValue = mapError(xa_result, ETrue);

    RET_ERR_IF_ERR(returnValue);

    if ((state == XA_RECORDSTATE_STOPPED)

        || (state == XA_RECORDSTATE_RECORDING)) {

        TRACE_LOG(_L("XARecordSessionImpl::Record: Setting State to Paused..."));

        xa_result = (*m_RecordItf)->SetRecordState(m_RecordItf, XA_RECORDSTATE_PAUSED);

        returnValue = mapError(xa_result, ETrue);

        RET_ERR_IF_ERR(returnValue);

        TRACE_LOG(_L("XARecordSessionImpl::Record: SetState to Paused"));

    }

    TRACE_FUNCTION_EXIT;

    return returnValue;

}

TInt32 XARecordSessionImpl::stop()

{

    TRACE_FUNCTION_ENTRY;

    TInt32 returnValue(KErrGeneral);

    if (!m_MORecorder || !m_RecordItf) {

        TRACE_LOG(_L("XARecordSessionImpl::Record: MORecorder/RecordItf is not created"));

        return returnValue;

    }

    XAuint32 state;

    XAresult xa_result = (*m_RecordItf)->GetRecordState(m_RecordItf, &state);

    returnValue = mapError(xa_result, ETrue);

    RET_ERR_IF_ERR(returnValue);

    if ((state == XA_RECORDSTATE_PAUSED)

        || (state == XA_RECORDSTATE_RECORDING)) {

        TRACE_LOG(_L("XARecordSessionImpl::Record: Setting State to Stopped..."));

        xa_result = (*m_RecordItf)->SetRecordState(m_RecordItf, XA_RECORDSTATE_STOPPED);

        returnValue = mapError(xa_result, ETrue);

        RET_ERR_IF_ERR(returnValue);

        TRACE_LOG(_L("XARecordSessionImpl::Record: SetState to Stopped"));

    }

    TRACE_FUNCTION_EXIT;

    return returnValue;

}

TInt32 XARecordSessionImpl::duration(TInt64 &aDur)

{

    TRACE_FUNCTION_ENTRY;

    TInt32 returnValue(KErrGeneral);

    if (!m_MORecorder || !m_RecordItf) {

        TRACE_LOG(_L("XARecordSessionImpl::Duration: MORecoder/RecordItf is not created"));

        return returnValue;

    }

    XAmillisecond milliSec;

    XAresult xa_result = (*m_RecordItf)->GetPosition(m_RecordItf, &milliSec);

    returnValue = mapError(xa_result, ETrue);

    if (returnValue == KErrNone)

        aDur = (TInt64)milliSec;

    TRACE_FUNCTION_EXIT;

    return returnValue;

}

void XARecordSessionImpl::cbMediaRecorder(

                            XAObjectItf /*caller*/,

                            const void */*pContext*/,

                            XAuint32 event,

                            XAresult result,

                            XAuint32 /*param*/,

                            void */*pInterface*/)

{

    TRACE_FUNCTION_ENTRY;

    switch (event) {

    case XA_OBJECT_EVENT_RESOURCES_LOST:

        m_Parent.cbRecordingStopped();

        break;

        case XA_OBJECT_EVENT_RUNTIME_ERROR: {

            switch (result) {

            case XA_RESULT_RESOURCE_LOST:

                m_Parent.cbRecordingStopped();

                break;

            default:

                break;

            }; /* of switch (result) */

        }

    default:

        break;

    } /* of switch (event) */

    TRACE_FUNCTION_EXIT;

}

void XARecordSessionImpl::cbRecordItf(

                        XARecordItf /*caller*/,

                        void */*pContext*/,

                        XAuint32 event)

{

    TRACE_FUNCTION_ENTRY;

    switch(event) {

    case XA_RECORDEVENT_HEADATLIMIT:

        TRACE_LOG(_L("XA_RECORDEVENT_HEADATLIMIT"));

        break;

    case XA_RECORDEVENT_HEADATMARKER:

        TRACE_LOG(_L("XA_RECORDEVENT_HEADATMARKER"));

        break;

    case XA_RECORDEVENT_HEADATNEWPOS: {

        TInt32 returnValue;

        XAresult xa_result;

        XAmillisecond milliSec;

        xa_result = (*m_RecordItf)->GetPosition(m_RecordItf, &milliSec);

        returnValue = mapError(xa_result, ETrue);

        if (returnValue == KErrNone)

            m_Parent.cbDurationChanged((TInt64)milliSec);

        }

        break;

    case XA_RECORDEVENT_HEADMOVING:

        TRACE_LOG(_L("XA_RECORDEVENT_HEADMOVING"));

        m_Parent.cbRecordingStarted();

        break;

    case XA_RECORDEVENT_HEADSTALLED:

        TRACE_LOG(_L("XA_RECORDEVENT_HEADSTALLED"));

        break;

    case XA_RECORDEVENT_BUFFER_FULL:

        TRACE_LOG(_L("XA_RECORDEVENT_BUFFER_FULL"));

        break;

    default:

        TRACE_LOG(_L("UNKNOWN RECORDEVENT EVENT"));

        break;

    } /* of switch(event) */

    TRACE_FUNCTION_EXIT;

}

/* For QAudioEndpointSelector begin */

void XARecordSessionImpl::getAudioInputDeviceNames(RArray<TPtrC> &aArray)

{

    TRACE_FUNCTION_ENTRY;

    for(TInt index = 0; index < m_AudioInputDeviceNames->MdcaCount(); index++)

        aArray.Append(m_AudioInputDeviceNames->MdcaPoint(index));

    TRACE_FUNCTION_EXIT;

}

TInt32 XARecordSessionImpl::defaultAudioInputDevice(TPtrC &endPoint)

{

    TRACE_FUNCTION_ENTRY;

    TInt32 err(KErrGeneral);

        endPoint.Set(m_DefaultAudioInputDeviceNames->MdcaPoint(0));

    TRACE_FUNCTION_EXIT;

    return err;

}

TInt32 XARecordSessionImpl::activeAudioInputDevice(TPtrC &endPoint)

{

    TRACE_FUNCTION_ENTRY;

    TInt32 returnValue(KErrGeneral);

    TBool found(EFalse);

    TInt index = 0;

    for(; index < m_InputDeviceIDs.Count(); index++) {

        if (m_InputDeviceIDs[index] == m_InputDeviceId) {

            found = ETrue;

            break;

        }

    }

    /* Comparing found with ETrue produces linker error */

    if (found == true) {

        endPoint.Set(m_AudioInputDeviceNames->MdcaPoint(index));

        returnValue = KErrNone;

    }

    TRACE_FUNCTION_EXIT;

    return returnValue;

}

TBool XARecordSessionImpl::setAudioInputDevice(const TDesC &aDevice)

{

    TRACE_FUNCTION_ENTRY;

    /* validate if we can set input device id */

    TBool found(EFalse);

    m_InputDeviceId = 0;

    TInt index = 0;

    for(; index < m_AudioInputDeviceNames->MdcaCount(); index++) {

        if (m_AudioInputDeviceNames->MdcaPoint(index).Compare(aDevice) == 0) {

            found = ETrue;

            break;

        }

    }

    if (found == true) {

        m_InputDeviceId = m_InputDeviceIDs[index];

    }

    TRACE_FUNCTION_EXIT;

    return found;

}

void XARecordSessionImpl::cbAvailableAudioInputsChanged(

                                    XAAudioIODeviceCapabilitiesItf /*caller*/,

                                    void */*pContext*/,

                                    XAuint32 deviceID,

                                    XAint32 /*numInputs*/,

                                    XAboolean isNew)

{

    TRACE_FUNCTION_ENTRY;

    /* If a new device is added into the system, append it to available input list */

    if (isNew == XA_BOOLEAN_TRUE) {

        XAAudioInputDescriptor audioInputDescriptor;

        m_InputDeviceIDs.Append(deviceID);

        XAresult xa_result = (*m_AudioIODevCapsItf)->QueryAudioInputCapabilities(

                m_AudioIODevCapsItf,

                deviceID,

                &audioInputDescriptor);

        if ((mapError(xa_result, ETrue)) == KErrNone) {

            TUint8* inDevNamePtr = audioInputDescriptor.deviceName;

            TUint8* tempPtr = audioInputDescriptor.deviceName;

            TInt32 inDevNameLength = 0;

            while (*tempPtr++) inDevNameLength++;

            TPtrC8 ptr(inDevNamePtr, inDevNameLength);

            /* Convert 8 bit to 16 bit */

            TBuf16<KMaxNameLength> name;

            name.Copy(ptr);

            /* Using TRAP with returnValue results in compiler error */

            TRAP_IGNORE(m_AudioInputDeviceNames->AppendL(name));

        }

    }

    else {

        /* an available device has been removed from the the system, remove it from

         * available input list and also default list */

        TBool found(EFalse);

        TInt index = 0;

        for (; index < m_InputDeviceIDs.Count(); index++) {

            if (deviceID == m_InputDeviceIDs[index]) {

                found = ETrue;

                break;

            }

        }

        if (found == true) {