/*

* Copyright (c) 2005 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 file for 3GPAudioRecordControllerPlugin

*

*/

#include "3GPAudioRecordControllerPluginUIDs.hrh"

#include "3GPAudioRecordControllerPlugin.h"

#include "3GPAudioRecordControllerEncoderBuilder.h"

#include "3GPAudioRecordControllerResource.h"

#include "DevSoundAudioInput.h"

#include <mmffile.h>

#include "DebugMacros.h"

// CONSTANTS

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

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::C3GPAudioRecordControllerPlugin

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

C3GPAudioRecordControllerPlugin::C3GPAudioRecordControllerPlugin()

    :     iMP4Handle(NULL),

        iEncoderBuilder(NULL),

        iBuffer(NULL)

    {

    iEnableDelayWrite = EFalse;

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::ConstructL()

    {

    CAdvancedAudioRecordController::ConstructL();

    DP0(_L("C3GPAudioRecordControllerPlugin::ConstructL(1)"));

    iEncoderBuilder = C3GPAudioRecordControllerEncoderBuilder::NewL();

    DP0(_L("C3GPAudioRecordControllerPlugin::ConstructL(2)"));

    iAudioResource = C3GPAudioRecordControllerResource::NewL(K3GPResourceAAC);

    TAapProperties aapProperties = iAudioResource->PropertiesL();

    DP0(_L("C3GPAudioRecordControllerPlugin::ConstructL(3)"));

    iSharedBufferMaxNum = aapProperties.iSharedBufferMaxNum;    // default size

    iSharedBufferMaxSize = aapProperties.iSharedBufferMaxSize;    // default size

    iMetaData = C3GPAudioRecordControllerMetaData::NewL();

    iMetaData->AddMetaDataWriteParserL(this);

    RArray<TInt>& codecConfigData = CONST_CAST(RArray<TInt>&, iAudioResource->CodecConfigParametersL());

    iSampleRate = codecConfigData[1]; // default sample rate for devsound

    iChannels = codecConfigData[3];   // default channels for devsound

    DP0(_L("C3GPAudioRecordControllerPlugin::ConstructL(4)"));

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

C3GPAudioRecordControllerPlugin* C3GPAudioRecordControllerPlugin::NewL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::NewL"));

    C3GPAudioRecordControllerPlugin* self = new(ELeave) C3GPAudioRecordControllerPlugin;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::~C3GPAudioRecordControllerPlugin

// Destructor

// -----------------------------------------------------------------------------

//

C3GPAudioRecordControllerPlugin::~C3GPAudioRecordControllerPlugin()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::~C3GPAudioRecordControllerPlugin"));

    TRAP_IGNORE(CloseMP4ComposerL());

    delete iMetaData;

    delete iEncoderBuilder;

    delete iAudioResource;

    delete iAudioInput;

    delete iBuffer;

    iSupportedChannels.Close();

    iSharedBuffers.ResetAndDestroy();

    iSharedBuffers.Close();

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::DoAddDataSourceL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::DoAddDataSourceL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::DoAddDataSourceL"));

    iAudioInput = CDevSoundAudioInput::NewL(iPrioritySettings, *this, *iMMFDevSound);

    iEncoderType = K3GPEncoder;

    iDataType = TFourCC(' ','A','A','C');

    if ( iDataSink )

        {

        CAdvancedAudioEncoder* encoder = iEncoderBuilder->BuildEncoderL(iEncoderType, iDataType);

        // AudioInput takes ownership of Encoder object

        iAudioInput->SetEncoder(encoder);

        iAudioInput->PrimeL();

        DetermineSupportedNumChannelsL();

        iAudioInput->StopL();

        }

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::DoAddDataSinkL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::DoAddDataSinkL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::DoAddDataSinkL"));

    CMMFClip* clip = STATIC_CAST(CMMFClip*, iDataSink);

    if ( iDataSink->DataSinkType() == KUidMmfFileSink )

        {

        iSinkType = KUidMmfFileSink;

        clip->SinkPrimeL();

        clip->SinkThreadLogon(*this);

        iDriveNumber = GetDriveNumber(STATIC_CAST(CMMFFile*, iDataSink)->FileDrive());

        TInt size = clip->Size();

 		if (size == 0)     // check for size = 0, to verify whether header has been written

            {

            WriteHeaderL();

            }

        clip->SinkStopL();

        TRAP_IGNORE(UpdateMP4DurationL());      // get duration if file contains valid recorded data

        }

    else    // KUidMmfDescriptorSink

        {

        iSinkType = KUidMmfDescriptorSink;

        }

    if ( iDataSource )

        {

        CAdvancedAudioEncoder* encoder = iEncoderBuilder->BuildEncoderL(iEncoderType, iDataType);

        // AudioInput takes ownership of Encoder object

        iAudioInput->SetEncoder(encoder);

        iAudioInput->PrimeL();

        DetermineSupportedNumChannelsL();

        iAudioInput->StopL();

        }

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::DoStopL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::DoStopL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::DoStopL"));

    iAudioInput->StopL();

    if (!iEnableDelayWrite)

        DoCommitMetaDataL();

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::EmptyBufferL

// -----------------------------------------------------------------------------

//

TInt C3GPAudioRecordControllerPlugin::EmptyBufferL(

    CMMFBuffer* aBuffer )

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::EmptyBufferL"));

    TUint buffersize = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data().Length();

    CMMFDataBuffer* buf = STATIC_CAST(CMMFDataBuffer*, aBuffer);

    TUint8* buffer = CONST_CAST(TUint8*, buf->Data().Ptr());

    MP4Err err = MP4ComposeWriteAudioFrames(iMP4Handle, buffer, buffersize, 0, 1024);

    aBuffer->SetStatus(EAvailable);

    iDuration = PositionL().Int64();   // update duration during recording state, base on position

    return TranslateMP4Err(err);

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::PauseL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::PauseL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::PauseL"));

    User::Leave(KErrNotSupported);

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::PrimeL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::PrimeL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::PrimeL"));

    if ( iState == ERecording )

        {

        User::Leave(KErrNotReady);

        }

    // Since Append is not supported on Recording, this function should leave if Duration is not equal to 0

    if (iDuration == 0)

        {

        PrepareMP4ComposerL();

        // Read the default codec configuration parameters from resource file

        RArray<TInt>& codecConfigData = CONST_CAST(RArray<TInt>&, iAudioResource->CodecConfigParametersL());

        codecConfigData[1] = iSampleRate; // configure the decoder with any user modified values.

        codecConfigData[3] = iChannels;

        iAudioInput->ConfigureL(iSampleRate, iChannels, iDataType, codecConfigData);

        iAudioInput->PrimeL();

        }

    else

        User::Leave(KErrNotSupported);

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::Play

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::PlayL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::PlayL"));

    MP4Err err = MP4ComposeAddAudioDescription(iMP4Handle, (mp4_u32)iSampleRate, 1, 0);

    DP1(_L("MP4ComposeAddAudioDescription err = %d"), err);

    User::LeaveIfError(TranslateMP4Err(err));

    ResetSharedBuffersL(iSharedBufferMaxNum, iSharedBufferMaxSize);

    iAudioInput->RecordL(&iSharedBuffers);

    iState = ERecording;

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::StopL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::StopL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::StopL"));

    switch ( iState )

        {

        case ERecording:

            DoStopL();

            iState = EStopped;

            break;

        case EStopped:

            break;

        default:

            Panic(EBadState);

            break;

        }

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::SetPositionL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::SetPositionL(

    const TTimeIntervalMicroSeconds& aPosition )

    {

    DP1(_L("C3GPAudioRecordControllerPlugin::SetPositionL pos = %d"), aPosition.Int64());

    if ( aPosition > 0 ) // 3gp library doesn't support set position.

        {

        User::Leave(KErrNotSupported);

        }

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::SendEvent

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::SendEvent(

    const TMMFEvent& aEvent )

    {

    DP1(_L("C3GPAudioRecordControllerPlugin::SendEvent(%d)"), aEvent.iErrorCode);

    iTimePositionInMicroSecs = 0;

    iState = EStopped;

    TRAP_IGNORE(CloseMP4ComposerL());

    SendEventToClient(aEvent);

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::MarcCropL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::MarcCropL(

    TBool /*aToEnd*/ )

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::MarcCropL"));

    User::Leave(KErrNotSupported);

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::MarcAddMetaDataEntryL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::MarcAddMetaDataEntryL(const CMMFMetaDataEntry& aNewEntry)

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::MarcAddMetaDataEntryL"));

    iMetaData->AddMetaDataEntryL(aNewEntry);

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::PrepareMP4ComposerL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::PrepareMP4ComposerL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::PrepareMP4ComposerL"));

    MP4Err err = 0;

    if ( iSinkType == KUidMmfFileSink )

        {

        CMMFFile* file = STATIC_CAST(CMMFFile*, iDataSink);

        RFile fileHandle;

        TRAP_IGNORE(fileHandle = file->FileL());

        if (file->FilePath().Length() && (fileHandle.SubSessionHandle() == 0)) // File Path exists, not file handle

            {

            TFileName fileName = file->FullName();

            err = MP4ComposeOpen(&iMP4Handle, (MP4FileName) fileName.Ptr(), MP4_TYPE_MPEG4_AUDIO);

            DP1(_L("MP4ComposeOpen err = %d - Using File Name"), err);

            }

        else

            {

            err = MP4ComposeOpenFileHandle(&iMP4Handle, &fileHandle, (TDriveNumber)EDriveC, MP4_TYPE_MPEG4_AUDIO);

            DP1(_L("MP4ComposeOpen err = %d - Using File Handle"), err);

            }

        User::LeaveIfError(TranslateMP4Err(err));

        mp4_u32 flags = (MP4_FLAG_METADATALAST | MP4_FLAG_GENERATE_MP4 | MP4_FLAG_LONGCLIP );

        err = MP4ComposeSetFlags(iMP4Handle, flags);

        User::LeaveIfError(TranslateMP4Err(err));

        }

    else    // KUidMmfDescriptorSink

        {

        User::Leave(KErrNotSupported);

        }

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::UpdateMP4DurationL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::UpdateMP4DurationL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::UpdateMP4DurationL"));

    MP4Err err = 0;

    mp4_u32 audioLength, audioType, timeScale, averateBitRate;

    mp4_u8 framesPerSample;

    if ( iSinkType == KUidMmfFileSink )

        {

        CMMFFile* file = STATIC_CAST(CMMFFile*, iDataSink);

        if (file->FilePath().Length()) // File Path exists, not file handle

            {

            TFileName fileName = file->FullName();

            err = MP4ParseOpen(&iMP4Handle, (MP4FileName) fileName.Ptr());

            DP1(_L("MP4ParseOpen err = %d - Using File Name"), err);

            }

        else

            {

            err = MP4ParseOpenFileHandle(&iMP4Handle, &(file->FileL()));

            DP1(_L("MP4ParseOpen err = %d - Using File Handle"), err);

            }

        User::LeaveIfError(TranslateMP4Err(err));

        }

    err = MP4ParseRequestAudioDescription(iMP4Handle, &audioLength, &audioType,

        &framesPerSample, &timeScale, &averateBitRate);

    MP4ParseClose(iMP4Handle);

    iMP4Handle = NULL;

    User::LeaveIfError(TranslateMP4Err(err));

    iDuration = (TInt64)audioLength*1000;   // convert to microseconds

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::TranslateMP4Err

// -----------------------------------------------------------------------------

//

TInt C3GPAudioRecordControllerPlugin::TranslateMP4Err(

    MP4Err aError )

    {

    TInt err;

    switch ( aError )

        {

        case MP4_OK:

            err = KErrNone;

            break;

        case MP4_OUT_OF_MEMORY:

            err = KErrNoMemory;

            break;

        case MP4_NOT_AVAILABLE:

            err = KErrNotReady;

            break;

        case MP4_FILE_ERROR:

            err = KErrBadHandle;

            break;

        case MP4_INVALID_TYPE:

            err = KErrNotSupported;

            break;

        case MP4_TIMESCALE_NOT_SET:

            err = KErrNotReady;

            break;

        case MP4_NOT_STREAMABLE:

        case MP4_NO_REQUESTED_FRAME:

        case MP4_CANT_SEEK:

        case MP4_INVALID_INPUT_STREAM:

        case MP4_NO_FRAME:

            err = KErrArgument;

            break;

        case MP4_ERROR:

        case MP4_FILE_MODE:

        case MP4_BUFFER_TOO_SMALL:

        case MP4_END_OF_VIDEO:

        case MP4_NO_VIDEO:

        case MP4_NO_AUDIO:

            err = KErrGeneral;

            break;

        case MP4_METADATA_ERROR:

            err = KErrWrite;

            break;

        default:

            err = KErrGeneral;

            break;

        }

    return err;

    }

// -----------------------------------------------------------------------------

// C3GPAudioRecordControllerPlugin::WriteDecoderSpecificInfoL

// -----------------------------------------------------------------------------

//

void C3GPAudioRecordControllerPlugin::WriteAudioDecoderSpecificInfoL()

    {

    DP0(_L("C3GPAudioRecordControllerPlugin::WriteDecoderSpecificInfoL"));

    HBufC8* decSpecInfo = NULL;

    TUint8* buf = NULL;

    decSpecInfo = HBufC8::NewLC(2);

    buf = CONST_CAST(TUint8*, decSpecInfo->Ptr());

    // constructing decoder specific information

    TInt profile = 2; // Object type 2 AAC-LC

    buf[0] = profile << 3;

    TInt sampleFreqIndex = 0;

    switch ( iSampleRate ) // maping sampling rate to sampling frequency index

        {

        case 96000:

            sampleFreqIndex = 0x0;

            break;

        case 88200:

            sampleFreqIndex = 0x1;

            break;

        case 64000:

            sampleFreqIndex = 0x2;

            break;

        case 48000:

            sampleFreqIndex = 0x3;

            break;

        case 44100:

            sampleFreqIndex = 0x4;

            break;

        case 32000:

            sampleFreqIndex = 0x5;

            break;

        case 24000:

            sampleFreqIndex = 0x6;

            break;

        case 22050:

            sampleFreqIndex = 0x7;

            break;

        case 16000:

            sampleFreqIndex = 0x8;

            break;

        case 12000: