// Copyright (c) 2006-2009 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:

//

// INCLUDE FILES

#include <e32base.h>

#include <f32file.h>

#include "mp4atom.h"

#include "filewriter.h"

// MACROS

// Debug print macro

#ifdef _DEBUG

#include <e32svr.h>

//#define PRINT(x) RDebug::Print x

#define PRINT(x)

#else

#define PRINT(x)

#endif

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

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

// CFileWriter::CFileWriter

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

// might leave.

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

//

CFileWriter::CFileWriter( TInt aInitSetSize, TInt aOutputBufferSizeSmall, TInt aOutputBufferSizeLarge ):

	CActive( EPriorityHigh ),

	iSetSize( aInitSetSize ),

	iOutputBufferSizeSmall( aOutputBufferSizeSmall ),

	iOutputBufferSizeLarge( aOutputBufferSizeLarge )

    {

    }

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

// CFileWriter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CFileWriter::ConstructL( RFile64& aFile )

    {

    PRINT((_L("CFileWriter::ConstructL() in")));         

    iFlush = EFalse;

    iError = KErrNone;

    iOutputFile = &aFile;

    iWritingStarted = EFalse;

    iOutputBufferSize = KFileWriterBufferSizeSmall;

    iMaxOutputBufHardLimit = KFileWriterHardBufLimit;

    iMaxOutputBufSoftLimit = KFileWriterSoftBufLimit;

    iMemReadyForWriting = EFalse;

    iInputBuf = NULL;

    iEmptyBufferQueue.Reset();

    iFullBufferQueue.Reset();

    AllocateBuffersL();

    CActiveScheduler::Add(this);

    PRINT((_L("CFileWriter::ConstructL() out")));         

    }

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

// CFileWriter::NewL

// Two-phased constructor.

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

//

CFileWriter* CFileWriter::NewL( RFile64& aFile, TInt aInitSetSize, TInt aOutputBufferSizeSmall, TInt aOutputBufferSizeLarge )

    {

    CFileWriter* self = new(ELeave) CFileWriter( aInitSetSize, aOutputBufferSizeSmall, aOutputBufferSizeLarge );

    CleanupStack::PushL(self);

    self->ConstructL( aFile );

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CFileWriter::~CFileWriter()

    {

    PRINT((_L("CFileWriter::~CFileWriter() in")));         

    if ( IsActive() )

        {

        if ( iAsyncWritingOngoing )

            {

            Cancel();    

            }

        else

            {

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

            Cancel();

            }

        }

    if ( iInputBuf )

        {

        delete iInputBuf;

        }

    iEmptyBufferQueue.ResetAndDestroy();

    iFullBufferQueue.ResetAndDestroy();

    PRINT((_L("CFileWriter::~CFileWriter() out")));         

    }

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

// CFileWriter::UpdateOutputFileSize()

// Updates output file size and reserves extra space for following writing 

// if iSetSize is set.  

// Takes into account if the position in the file was changed.

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

//

void CFileWriter::UpdateOutputFileSize()

    {

    TInt64 pos = 0;

    PRINT((_L("e_cfilewriter_write_updateoutputfilesize_seek 1")));

    iOutputFile->Seek(ESeekCurrent, pos);

    PRINT((_L("e_cfilewriter_write_updateoutputfilesize_seek 0")));

    PRINT((_L("CFileWriter::UpdateOutputFileSize() pos: %Ld"), pos));

    PRINT((_L("CFileWriter::UpdateOutputFileSize() iOutputFileSize: %Ld"), iOutputFileSize));

    PRINT((_L("CFileWriter::UpdateOutputFileSize() iSetSize: %Ld"), iSetSize));

    if (pos > iOutputFileSize) 

        {

        iOutputFileSize = pos;

        }

    while (iOutputFileSize >= iSetSize) 

        {

        PRINT((_L("e_cfilewriter_updateoutputfilesize_setsize 1")));                     

        iOutputFile->SetSize( iSetSize );

        PRINT((_L("e_cfilewriter_updateoutputfilesize_setsize 0")));                     

        }

    }

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

// CFileWriter::Write( const TDesC8& aBuf )

// Writes incoming buffer data to internal buffers for writing to disk.

// (other items were commented in a header).

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

//

TInt CFileWriter::Write( const TDesC8& aBuf )

    {

    PRINT(_L("CFileWriter::Write() in"));

    PRINT((_L("e_cfilewriter_write 1")));

    iWritingStarted = ETrue;

    if ( !iMemReadyForWriting )

    	{

    	return KErrNoMemory;

    	}

    PRINT((_L("e_cfilewriter_write_adddatatobuffer 1")));	

    TInt error = AddDataToBuffer( aBuf );

    PRINT((_L("e_cfilewriter_write_adddatatobuffer 0")));	    

    if ( error != KErrNone )

        {

        PRINT((_L("CFileWriter::Write() buffer write error: %d"), error));         

        return error;

        }

    PRINT((_L("CFileWriter::Write() Write Buffer, Status: Full:%d Empty:%d "), 

                    iFullBufferQueue.Count(), iEmptyBufferQueue.Count() ));

    if ( iAsyncWritingOngoing )

        {

        if ( iFullBufferQueue.Count() >= iMaxOutputBufHardLimit )

            {

            PRINT((_L("CFileWriter::Write() Waiting async write to complete")));

			PRINT((_L("e_cfilewriter_write_wait_async 1")));            

            User::WaitForRequest( iStatus );

			PRINT((_L("e_cfilewriter_write_wait_async 0")));            

            PRINT((_L("CFileWriter::Write() Async write done")));

            TRAP(error, RunL());

            if (error != KErrNone)

            	{

            	PRINT((_L("CFileWriter::Write() call runL leave, error: %d"), error));         

                return error;

            	}

            }

        }

    else

        {

        if ( iFullBufferQueue.Count() )

            {

            PRINT(_L("CFileWriter::Write() writing async"));                     

            PRINT((_L("e_cfilewriter_write_startwrite 1")));                     

            iOutputFile->Write( *iFullBufferQueue[0], iStatus );

            PRINT((_L("e_cfilewriter_write_startwrite 0")));

            iAsyncWritingOngoing = ETrue;

            if ( !IsActive() )

                {

                SetActive();

                }

            }

        }

    PRINT(_L("CFileWriter::Write() out"));

    PRINT((_L("e_cfilewriter_write 0")));    

    return error;

    }

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

// CFileWriter::Flush( const TDesC8& aBuf )

// Flush internal buffers to disk.

// (other items were commented in a header).

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

//

TInt CFileWriter::Flush( const TDesC8& aBuf )

    {

    PRINT(_L("CFileWriter::Flush() in"));

    PRINT((_L("e_cfilewriter_flush 1")));

 	if ( !iMemReadyForWriting )

 		{

 		return KErrNoMemory;

 		}

    iWritingStarted = ETrue;

    PRINT((_L("e_cfilewriter_flush_adddatatobuf 1")));

    TInt error = AddDataToBuffer( aBuf );

    if ( error != KErrNone )

        {

        return error;

        }

	PRINT((_L("e_cfilewriter_flush_adddatatobuf 0")));        

    PRINT((_L("CFileWriter::Flush() FullCount: %d "), iFullBufferQueue.Count()));

    iFlush = ETrue;

    if ( iAsyncWritingOngoing )

        {

        PRINT((_L("CFileWriter::Flush() Waiting async write to complete")));

        PRINT((_L("e_cfilewriter_flush_waitasynctostop 1")));

        User::WaitForRequest( iStatus );

        PRINT((_L("e_cfilewriter_flush_waitasynctostop 0")));

        PRINT((_L("CFileWriter::Flush() Async write done, flushing")));

        TRAP(error, RunL());

        if (error != KErrNone)

        	{

        	PRINT((_L("CFileWriter::Flush() call runL leave, error: %d"), error));         

            return error;

        	}

        }

    while ( iFullBufferQueue.Count() )

        {

        PRINT((_L("e_cfilewriter_flush_writequeue_sync 1")));

        error = iOutputFile->Write( *iFullBufferQueue[0] );

        PRINT((_L("e_cfilewriter_flush_writequeue_sync 0")));

        PRINT((_L("e_cfilewriter_flush_remove_buf 1")));

        if ( error == KErrNone )

            {

            UpdateOutputFileSize();

            iFullBufferQueue[0]->Des().Zero();

            if ( iEmptyBufferQueue.Append( iFullBufferQueue[0] ) )

                {

                PRINT(_L("CFileWriter::Flush() Append failed"));

                delete ( iFullBufferQueue[0] ); 

                }

            iFullBufferQueue.Remove( 0 );

            }

        else

            {

            PRINT((_L("CFileWriter::Flush() fullBufQueue write failed, error: %d"), error));

            iFlush = EFalse;

            return error;

            }

        PRINT((_L("e_cfilewriter_flush_remove_buf 0")));    

        }

    if ( iInputBuf->Length() )

        {

        PRINT((_L("e_cfilewriter_flush_writeinput_sync 1")));

        error = iOutputFile->Write( *iInputBuf );

        PRINT((_L("e_cfilewriter_flush_writeinput_sync 0")));

        if ( error == KErrNone )

            {

            UpdateOutputFileSize();

            iInputBuf->Des().Zero();

            }

        else

            {

            PRINT((_L("CFileWriter::Flush() inputbuf write failed, error: %d"), error));

            iFlush = EFalse;

            return error;

            }

        }

    iFlush = EFalse;

    PRINT((_L("CFileWriter::Flush() FullCount: %d <= Should be 0"), iFullBufferQueue.Count()));

    PRINT(_L("CFileWriter::Flush() out"));

    PRINT((_L("e_cfilewriter_flush 0")));    

    return KErrNone;

    }

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

// CFileWriter::SetOutputBufferSize( TOutputBufferSize aBufferSize )

// Set output buffer sizes.

// (other items were commented in a header).

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

//

TInt CFileWriter::SetOutputBufferSize( TOutputBufferSize aBufferSize, MP4Handle aHandle )

    {

    MP4HandleImp handle = (MP4HandleImp)aHandle;    

    TInt size = 0;

    if ( iWritingStarted )

        {

        return KErrNotReady;

        }

    if ( aBufferSize == EBufferSizeSmall ) 

        {

        size = iOutputBufferSizeSmall;

        }

    else if ( aBufferSize == EBufferSizeLarge ) 

        {

        size = iOutputBufferSizeLarge;

        }

    else if ( aBufferSize == EBufferSizeCustom )

        {

        size = handle->mediaWriteBufferSize;

        }

    else

        {

        return KErrArgument;    

        }

    if ( size == iOutputBufferSize )

        {

        return KErrNone;

        }

    else

        {

        iOutputBufferSize = size;

        }

    iMemReadyForWriting = EFalse;

    delete iInputBuf;

    iInputBuf = NULL;

    iEmptyBufferQueue.ResetAndDestroy();

    iFullBufferQueue.ResetAndDestroy();

    TRAPD(err, AllocateBuffersL() );

    return err;

    }

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

// CFileWriter::SetOutputBufferCount( MP4Handle aHandle )

// Set output buffer count.

// (other items were commented in a header).

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

//

void CFileWriter::SetOutputBufferCount( MP4Handle aHandle )

    {

    MP4HandleImp handle = (MP4HandleImp)aHandle;    

    if (  handle->writeBufferMaxCount >= 6 )     

        {

        iMaxOutputBufHardLimit = handle->writeBufferMaxCount;

        iMaxOutputBufSoftLimit = KFileWriterMinBufferCount + ((iMaxOutputBufHardLimit-KFileWriterMinBufferCount)/2);

        }

    }

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

// CFileWriter::AddDataToBuffer( const TDesC8& aBuf )

// Writes incoming data to internal buffers and buffer queues..

// (other items were commented in a header).

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

//

TInt CFileWriter::AddDataToBuffer( const TDesC8& aBuf )

    {

    PRINT(_L("CFileWriter::AddDataToBuffer() in"));

    TInt byteswritten = 0;

    TInt numbytes = 0;

    TInt available = 0; // Available bytes in write buffer

    TInt error = KErrNone;

    if ( iError != KErrNone )

        {

        PRINT((_L("CFileWriter::AddDataToBuffer() out, RunL iError: %d"), iError));

        return iError;

        }

    if ( iInputBuf == NULL )

    	{

    	return KErrNoMemory;

    	}

    while (byteswritten < aBuf.Length() )

        {

        available = iOutputBufferSize - iInputBuf->Length();

        if (available > 0)

            {

            numbytes = aBuf.Length() - byteswritten;

            if (numbytes > available)

                {

                numbytes = available;

                }

            iInputBuf->Des().Append( aBuf.Mid( byteswritten, numbytes ) );

            byteswritten += numbytes;

            }

        else // Buffer is full, write it to disk

            {

            // input is full, move full inputbuf to full buf queue

            if ( iFullBufferQueue.Append( iInputBuf ) != KErrNone )

                {

                PRINT(_L("CFileWriter::AddDataToBuffer() Append failed"));

                delete iInputBuf;

                iInputBuf = NULL;

                }

            if ( iEmptyBufferQueue.Count() == 0 )

                {

                // no empty buffers in queue, allocating new one

                TRAP(error, iInputBuf = HBufC8::NewL( iOutputBufferSize ));

                if ( error != KErrNone )

                    {

                    PRINT((_L("CFileWriter::AddDataToBuffer(), memory alloc failed: %d"), error));

                    iInputBuf = NULL;

                    iError = error;

                    break;

                    }

                }

            else

                {

                iInputBuf = iEmptyBufferQueue[ 0 ];

                iEmptyBufferQueue.Remove( 0 );

                }

            }

        }

    PRINT((_L("CFileWriter::AddDataToBuffer() out, error: %d"), error));

    return error;

    }

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

// CFileWriter::AllocateBuffersL()

// Allocates input and output buffers.

// (other items were commented in a header).

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

//

void CFileWriter::AllocateBuffersL()

    {

    PRINT((_L("CFileWriter::AllocateBuffersL() in, outbufsize: %d"), iOutputBufferSize));

    HBufC8* buf = NULL;

    TInt err = 0;

    iMemReadyForWriting = EFalse;

    iInputBuf = HBufC8::NewL( iOutputBufferSize );

    for( TInt i=0; i<KFileWriterMinBufferCount; i++ )

        {

        buf = HBufC8::NewL( iOutputBufferSize );

        err = iEmptyBufferQueue.Append( buf );

        if ( err )

            {

            delete ( buf );

            User::Leave( err );

            }

        }

    iMemReadyForWriting = ETrue;

    PRINT((_L("CFileWriter::AllocateBuffersL() out")));

    }

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

// CFileWriter::DoCancel()

// From CActive Cancels async request.

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

//

void CFileWriter::DoCancel()

    {

    }

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

// CFileWriter::RunL()

// From CActive Called when async request completes.

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

//

void CFileWriter::RunL()

    {

    PRINT(_L("CFileWriter::RunL() in"));

	PRINT((_L("e_cfilewriter_runl 1")));    

    iAsyncWritingOngoing = EFalse;

    if ( iStatus == KErrNone )

        {

        UpdateOutputFileSize();                    

        iFullBufferQueue[0]->Des().Zero();

        iError = iEmptyBufferQueue.Append( iFullBufferQueue[0] );

        if ( iError )

            {

            PRINT((_L("CFileWriter::RunL() Append failed 1 %d"), iError ));

            delete ( iFullBufferQueue[0] );

            iFullBufferQueue.Remove( 0 );

            return;

            }

        iFullBufferQueue.Remove( 0 );

        }

    else

        {

        PRINT((_L("CFileWriter::RunL() Write error in previous async: %d "), iStatus.Int() ));