/*

* Copyright (c) 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 Camera image encoder

*

*/

#include <imageconversion.h>

#include <ExifRead.h>

#include <ecam.h> // MCameraBuffer

#include <eikenv.h>

#include "camlogging.h"

#include "camfilesaveutility.h"

#include "cambuffershare.h"

#include "camimageencoder.h"

// ===========================================================================

// Local constants

// Encoding flags

static const CImageEncoder::TOptions KConversionOptions =

  CImageEncoder::EOptionAlwaysThread;

// Other constants

static const TInt KImageIndex = 0;

static const TInt KPriority   = CActive::EPriorityHigh;

_LIT8( KMimeTypeDesc8, "image/jpeg" );

// ===========================================================================

// public constructor and destructor

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

// 2-phase constructor

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

//

CCamImageEncoder* 

CCamImageEncoder::NewL( MCamImageEncoderObserver& aObserver )

  {

  CCamImageEncoder* self = 

      new (ELeave) CCamImageEncoder( aObserver );

  CleanupStack::PushL( self );

  self->ConstructL();

  CleanupStack::Pop( self );

  return self;  

  }

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

// Destructor

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

//

CCamImageEncoder::~CCamImageEncoder()

  {

  PRINT( _L("Camera => ~CCamImageEncoder") );

  Cancel();

  ReleaseEncoder();

  SetInputBuffer( NULL );

  PRINT( _L("Camera <= ~CCamImageEncoder") );

  }

// ===========================================================================

// public methods

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

// StartConversionL

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

//

void

CCamImageEncoder::StartConversionL( CCamBufferShare* aBuffer )

  {

  PRINT( _L("Camera => CCamImageEncoder::StartConversionL") );

  // Cancel any previous action

  Cancel();

  ReleaseEncoder();

  if( aBuffer

   && aBuffer->SharedBuffer() )   

    {

    // Store the bitmap data. 

    // Need to release old buffer and reserve given one.

    SetInputBuffer( aBuffer );

    PRINT( _L("Camera <> CCamImageEncoder: Creating encoder..") );

    iEncoder = CImageEncoder::DataNewL( iEncodedData, 

                                        KMimeTypeDesc8(), 

                                        KConversionOptions );

    PRINT( _L("Camera <> CCamImageEncoder: get source bitmap..") );

    MCameraBuffer* buffer( iSharedInput->SharedBuffer()   );

    CFbsBitmap&    bitmap( buffer->BitmapL( KImageIndex ) );

    PRINT( _L("Camera <> CCamImageEncoder: start conversion..") );

    iEncoder->Convert( &iStatus, bitmap );

    SetActive();

    }

  else

    {

    PRINT( _L("Camera <> CCamImageEncoder: No bitmap provided, leave..") );

    User::Leave( KErrNotFound );    

    }

  PRINT( _L("Camera <= CCamImageEncoder::StartConversionL") );

  }

// ===========================================================================

// from CActive

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

// virtual DoCancel

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

//

void 

CCamImageEncoder::DoCancel()

  {

  PRINT( _L("Camera => CCamImageEncoder::DoCancel") );

  if( iEncoder )

    {

    iEncoder->Cancel();

    }

  ReleaseEncoder();

  SetInputBuffer( NULL );

  PRINT( _L("Camera <= CCamImageEncoder::DoCancel") );

  }

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

// virtual RunL

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

//

void 

CCamImageEncoder::RunL()

  {

  PRINT1( _L("Camera => CCamImageEncoder::RunL, iStatus:%d"), iStatus.Int() );

  switch( iStatus.Int() )

    {

    case KErrNone :

      {

      SetInputBuffer( NULL );

      // Notify observer

      NotifyObserver( KErrNone );

      // Source data and encoder not needed anymore

      ReleaseEncoder();

      break;

      }

    case KErrCancel :

    default :

      {

      User::Leave( iStatus.Int() );

      break;

      }

    }

  PRINT( _L("Camera <= CCamImageEncoder::RunL") );

  }

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

// virtual RunError

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

//

TInt 

CCamImageEncoder::RunError( TInt aError )

  {

  PRINT1( _L("Camera <= CCamImageEncoder::RunError(%d)"), aError );

  ReleaseEncoder();

  SetInputBuffer( NULL );

  // Leave has occurred in RunL.

  // Notify observer with error and NULL data.

  NotifyObserver( aError );

  PRINT( _L("Camera <= CCamImageEncoder::RunError") );

  return KErrNone;

  }

// ===========================================================================

// Private methods

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

// SetInputBuffer

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

//

void

CCamImageEncoder::SetInputBuffer( CCamBufferShare* aBuffer )

  {

  if( iSharedInput )

    {

    iSharedInput->Release();

    iSharedInput = NULL;

    }

  iSharedInput = aBuffer;

  if( iSharedInput )

    {

    iSharedInput->Reserve();

    }

  }

void 

CCamImageEncoder::ReleaseEncoder()

  {

  delete iEncoder;

  iEncoder = NULL;

  delete iEncodedData;

  iEncodedData = NULL;

  }

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

// NotifyObservers

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

//

void

CCamImageEncoder::NotifyObserver( TInt aStatus )

  {

  iObserver.ImageEncoded( aStatus, iEncodedData );

  iEncodedData = NULL;  // Ownership to observer

  }

// ===========================================================================

// private constructors

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

// 2nd phase constructor

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

//

void

CCamImageEncoder::ConstructL()

  {

  CActiveScheduler::Add( this );

  }

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

// 1st phase constructor

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

//

CCamImageEncoder::CCamImageEncoder( MCamImageEncoderObserver& aObserver )

  : CActive  ( KPriority ),

    iObserver( aObserver )

  {

  }

// end of file