/*

* Copyright (c) 2000 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

/* CEpoc32ImageDecoder class

 *

 * Every non-canned image has an image decoder associated with it. This is opened

 * when the image is created in order to get the size. This is an asynchronous

 * operation; "OpenComplete" is called when the opening is complete.

 *

 * The first time an image is displayed, "Decode" is called, which starts the

 * asynchrounous decoding process. When this completes, the image object is

 * updated with the decoded image, which then causes the new image to be

 * displayed.

 *

 * A decode is also done every time the frame number of an animated image is

 * changed.

 */

#include <bitdev.h>

#include <e32math.h>

#include "Epoc32ImageDecoder.h"

#include "nw_hed_contenthandler.h"

#include "nwx_logger.h"

#include "nw_imagech_epoc32contenthandler.h"

#include "nw_lmgr_boxvisitor.h"

#include "nw_lmgr_rootbox.h"

#include "nw_lmgr_slavepropertylist.h"

#include "nw_fbox_imagebuttonbox.h"

#include "nw_lmgr_imgcontainerbox.h"

#include "nw_lmgr_statictablebox.h"

#include "nw_xhtml_xhtml_1_0_tokens.h"

#include "nwx_statuscodeconvert.h"

#include "nw_dom_attribute.h"

#include "nw_dom_element.h"

#include "Oma2Agent.h"

#include "nwx_ctx.h"

/* The Media server seems to return a value larger than this if the animation

 * should end; it is 0xffff x 10; I'm not sure if this is significant. I didn't

 * find any documentation for this. */

#define MAXIMUM_DELAY 655350

_LIT8(KWbmpMimeType, "image/vnd.wap.wbmp");

_LIT8(KOtaMimeType, "image/vnd.nokia.ota-bitmap");

/* ------------------------------------------------------------------------- */

/* find context box for finding the DOM Tree */

/* ------------------------------------------------------------------------- */

static

NW_LMgr_Box_t*

NW_LMgr_ImageCH_Epoc32ContentHandler_FindContextBox_Decoder( NW_HED_DocumentNode_t* documentNode,

                                                    void* context )

  {

  NW_LMgr_Box_t* box = NULL;

  NW_LMgr_Box_t* contextBox = NULL;

  NW_LMgr_BoxVisitor_t boxVisitor;

  box = NW_HED_ContentHandlerOf( documentNode )->boxTree;

  if(NW_LMgr_BoxVisitor_Initialize( &boxVisitor, box ) != KBrsrSuccess )

    {

    return NULL;

    }

  while( ( box = NW_LMgr_BoxVisitor_NextBox( &boxVisitor, 0 ) ) != NULL )

    {

    if( ( NW_Object_IsInstanceOf( box, &NW_LMgr_ContainerBox_Class ) &&

         !NW_Object_IsInstanceOf( box->propList, &NW_LMgr_SlavePropertyList_Class ) )

         || NW_Object_IsClass( box, &NW_FBox_ImageButtonBox_Class )

         || NW_Object_IsDerivedFrom( box, &NW_LMgr_ImgContainerBox_Class ) )

      {

      NW_LMgr_PropertyValueType_t type = NW_CSS_ValueType_Object;

      NW_LMgr_PropertyValue_t value;

      if( NW_LMgr_Box_GetPropertyValue( box, NW_CSS_Prop_elementId, type, &value ) == KBrsrSuccess )

        {

        if( type == NW_CSS_ValueType_Object && value.object == context ||

            type == NW_CSS_ValueType_Integer && value.integer == NW_INT32_CAST(context) )

          {

          // We found a box that has element Id same as context

          contextBox = box;

          break;

          }

        }

      }

    }

  return contextBox;

  }

  /*

  * Get <img> attribute information from the box tree

  *

*/

TInt CEpoc32ImageDecoder::ImgAttrInfo()

    {

    NW_Image_AbstractImage_t* abstractImage = NULL;

    NW_Image_IImageObserver_t* imageObserver = NULL;

    NW_ImageCH_Epoc32ContentHandler_t* imgaeCHContentHandler = NULL;

    NW_HED_DocumentNode_t* documentNode = NULL;

    NW_LMgr_Box_t* cannedImageBox = NULL;

    NW_ADT_Vector_Metric_t numItems;

    TBrowserStatusCode status;

    TInt error = KErrNone;

    abstractImage = NW_Image_AbstractImageOf( iImage );

    numItems = NW_ADT_Vector_GetSize( NW_ADT_VectorOf( abstractImage->imageObserverList ) );

    if(numItems > 0)

        {

        imageObserver = *(NW_Image_IImageObserver_t**)

            NW_ADT_Vector_ElementAt( NW_ADT_VectorOf( abstractImage->imageObserverList ), 0 );//Take first one as this is prossed

        NW_ASSERT( imageObserver );

        imgaeCHContentHandler = (NW_ImageCH_Epoc32ContentHandler_t*)NW_Object_Interface_GetImplementer( imageObserver );

        if(NW_Object_IsInstanceOf( imgaeCHContentHandler, &NW_ImageCH_Epoc32ContentHandler_Class ) ) 

            {

            documentNode = NW_HED_DocumentNodeOf( imgaeCHContentHandler )->parent;

            cannedImageBox= 

                NW_LMgr_ImageCH_Epoc32ContentHandler_FindContextBox_Decoder( documentNode, imgaeCHContentHandler->context );

            }

        }/*end if(numItems > 0)*/

    if(cannedImageBox)

        {

        NW_LMgr_PropertyValue_t value;

        value.object = NULL;

        (void)NW_LMgr_Box_GetPropertyValue(NW_LMgr_BoxOf( cannedImageBox ), NW_CSS_Prop_elementId, NW_CSS_ValueType_Object, &value);

        if (value.object)

            {

            NW_Uint16 nodeToken;

            NW_Uint16 attrToken = 0;

            NW_DOM_AttributeListIterator_t listIter;

            NW_DOM_AttributeHandle_t attrHandle;

            NW_String_t attrValueStr;

            NW_Uint32 attrEncoding;

            NW_Ucs2 *ucs2AttrVal = NULL;

            NW_DOM_ElementNode_t* elementNode = (NW_DOM_ElementNode_t*)value.object;

            nodeToken = NW_DOM_Node_getNodeToken(elementNode);

            if(nodeToken == NW_XHTML_ElementToken_img)

                {

                if (NW_DOM_ElementNode_hasAttributes(elementNode) )

                    {

                    /* Go through all the attributes and check for height and width */

                    status = StatusCodeConvert(NW_DOM_ElementNode_getAttributeListIterator(elementNode, &listIter) );

                    if(status == KBrsrSuccess)

                        {

                        while (NW_DOM_AttributeListIterator_getNextAttribute(&listIter, &attrHandle)

                            == NW_STAT_WBXML_ITERATE_MORE) 

                            {

                            attrToken = NW_DOM_AttributeHandle_getToken(&attrHandle);

                            if( (attrToken == NW_XHTML_AttributeToken_width) ||

                                (attrToken == NW_XHTML_AttributeToken_height) )

                                {

                                attrEncoding = NW_DOM_AttributeHandle_getEncoding(&attrHandle);

                                status = StatusCodeConvert(NW_DOM_AttributeHandle_getValue(&attrHandle, &attrValueStr) );

                                if(status != KBrsrSuccess)

                                    {

                                    error = KErrGeneral;

                                    goto imgAttrInfoFinal;

                                    }

                                status = StatusCodeConvert( NW_String_stringToUCS2Char(&attrValueStr, attrEncoding, &ucs2AttrVal) );

                                if(status != KBrsrSuccess)

                                    {

                                    error = KErrGeneral;

                                    goto imgAttrInfoFinal;

                                    }

                                if(attrToken == NW_XHTML_AttributeToken_width)

                                    {

                                    iImage->srcWidth = NW_Str_Atoi(ucs2AttrVal);

                                    }

                                else if(attrToken == NW_XHTML_AttributeToken_height)

                                    {

                                    iImage->srcHeight =  NW_Str_Atoi(ucs2AttrVal);

                                    }

                                if(NW_String_getStorage(&attrValueStr) != NULL)

                                    {

                                    NW_String_deleteStorage(&attrValueStr);

                                    }

                                if(ucs2AttrVal != NULL)

                                    {

                                    NW_Mem_Free(ucs2AttrVal);

                                    }

                                }                

                            }/*end while*/

                        }/*end if(status == KBrsrSuccess)*/

                    else 

                        {

                        error = KErrGeneral;

                        goto imgAttrInfoFinal;

                        }

                    } /*end if (NW_DOM_ElementNode_hasAttributes(elementNode) )*/

                }/*end if(nodeToken == NW_XHTML_ElementToken_img)*/

            }/*end if(value.object) */

        }/*end if(cannedImageBox)) */

imgAttrInfoFinal:

    if( cannedImageBox )

        {

        // scale images if they are wider than the screen width in small screen mode

        // do not scale if image size is specified by the markup

        NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox( cannedImageBox );

        NW_ASSERT( rootBox != NULL );

        // image scaling only applies to small screen layout

        if( NW_LMgr_RootBox_GetSmallScreenOn( rootBox ) )

            {

            CGDIDeviceContext* deviceContext = NW_LMgr_RootBox_GetDeviceContext( rootBox );

            NW_ASSERT( deviceContext != NULL );

            const NW_GDI_Rectangle_t* rectangle = deviceContext->DisplayBounds();

            // check if the image is scalable. if the width/height proporition is bigger

            // than 10, then we do not scale no matter how big the image is        

            TInt imagProp = Max( iFrameInfo.iOverallSizeInPixels.iHeight / iFrameInfo.iOverallSizeInPixels.iWidth, 

                iFrameInfo.iOverallSizeInPixels.iWidth / iFrameInfo.iOverallSizeInPixels.iHeight );

            //

            if( imagProp < 10 &&

                iFrameInfo.iOverallSizeInPixels.iWidth > rectangle->dimension.width )

                {

                // scale the image down close to the screen width

                // 

                // As per Symbian code, the height and width can't be reduced more

                // than 1/8 th of original size. It is found that Symbian currently

                // handling size 1/8, 1/4, 1/2 or original frame size correctly. Also,

                // width and height need to reduce in ratio (e.g. if width is reduced by half then

                // height need to reduce by half). So,used the following alogorithm.

                TInt  halfHeight = (iFrameInfo.iOverallSizeInPixels.iHeight + 1)/2;

                TInt  halfWidth =  (iFrameInfo.iOverallSizeInPixels.iWidth + 1)/2;

                TInt  oneFourHeight = (iFrameInfo.iOverallSizeInPixels.iHeight + 3)/4;

                TInt  oneFourWidth =  (iFrameInfo.iOverallSizeInPixels.iWidth + 3)/4;

                TInt  oneEightHeight = (iFrameInfo.iOverallSizeInPixels.iHeight + 7)/8;

                TInt  oneEightWidth =  (iFrameInfo.iOverallSizeInPixels.iWidth + 7)/8;

                if( rectangle->dimension.width > halfWidth)

                    {

                    iImage->srcHeight = iFrameInfo.iOverallSizeInPixels.iHeight;

                    iImage->srcWidth = iFrameInfo.iOverallSizeInPixels.iWidth;

                    }

                else

                    {

                    if( rectangle->dimension.width > oneFourWidth)

                        {

                        iImage->srcHeight = halfHeight;

                        iImage->srcWidth = halfWidth;

                        }

                    else if( rectangle->dimension.width > oneEightWidth)

                        {

                        iImage->srcHeight = oneFourHeight;

                        iImage->srcWidth = oneFourWidth;

                        }

                    else

                        {

                        iImage->srcHeight = oneEightHeight;

                        iImage->srcWidth = oneEightWidth;

                        }

                    }

                }

            }      

        }

    return error;

    }/*end IMG_ATTR_INFO()*/

/*

 * NewL

 *

 * Creates a new CEpoc32ImageDecoder object

 *

 * Parameters:

 *    aImage: associated OOC image object

 *

 * Returns:

 *    New image decoder

 */

CEpoc32ImageDecoder* CEpoc32ImageDecoder::NewL(NW_Image_Epoc32Simple_t* aImage)

{

  CEpoc32ImageDecoder* self = new (ELeave) CEpoc32ImageDecoder(aImage);

  CleanupStack::PushL(self);

  self->ConstructL();

  CleanupStack::Pop(); //self

  return self;

}

/*

 * ConstructL

 *

 * Creates image converter, wait object, and opens connection

 * to image converter.

 */

void CEpoc32ImageDecoder::ConstructL()

  {

  CActiveScheduler::Add( this );

  // open is called by whoever intialized this dedoder. This changes was introduced by

  // the "image open started - open completed" queueing functionality.

  // OpenL();

  // CreateComplete();

  }

/*

 * CEpoc32ImageDecoder::CEpoc32ImageDecoder

 *

 * Constructor

 */

CEpoc32ImageDecoder::CEpoc32ImageDecoder(NW_Image_Epoc32Simple_t* aImage) : CActive ( CActive::EPriorityLow + 1 ),

    iState(ID_IDLE),

    iImageConverter(NULL),

    iImage(aImage),

    iImageDataPtr((const TUint8 *)NW_Image_Epoc32Simple_GetRawData(aImage), NW_Image_Epoc32Simple_GetRawDataLength(aImage)),

    iIsAnimated(NW_FALSE),

    iCurrentFrame(0),

    iBitmap(NULL),

    iMask(NULL),

    iImageHasNotBeenOpened(NW_TRUE),

    iMoreData( EFalse ),

    iFirstFrameComplete( EFalse ),

    iRawDataComplete( EFalse ),

	iDRMOutBuf(NULL),

	iFinished(EFalse)

  {

  }

void CEpoc32ImageDecoder::DeleteImageConverterBitmapMask()

  {

  if (iImageConverter != NULL)

    {

    /* Closing image converter. Cancels any outstanding operation */

    iImageConverter->Cancel();

    delete iImageConverter;

    iImageConverter = NULL;

    }

  delete iBitmap;

  delete iMask;

  iBitmap = NULL;

  iMask = NULL;

  // call shell to do some compress on heap ( prevent memory fregmentation )

  CShell* shellInstance = REINTERPRET_CAST(CShell*, (NW_Ctx_Get(NW_CTX_BROWSER_APP, 0)));

  NW_ASSERT( shellInstance != NULL );

  shellInstance->StartIdle();

  }

/*

 * CEpoc32ImageDecoder::CEpoc32ImageDecoder

 *

 * Destructor. Closes image converter, stops wait object, frees

 * data.

 */

CEpoc32ImageDecoder::~CEpoc32ImageDecoder()

  {

  Cancel();

  DeleteImageConverterBitmapMask();

  delete[] iDRMOutBuf;

  iDRMOutBuf = NULL;

  }

/*

 * Function for handling the DRM images.

 * This function checks if image is DRM 

 * then handle this.

 *

 *

 */

TInt CEpoc32ImageDecoder::CheckForDRMImage()

{

 TInt error = KErrNone;

 using namespace ContentAccess;

 RArray<ContentAccess::TAgent> agents;

 TInt i;

 HBufC8 *DRMInBuf;

 TPtr8 ptrInBuf(NULL,0,0);

 TInt inBufLen = 0;

 TRequestStatus status;

 TInt contentMgrErr = KErrNone;						 

 TAgent agentDRM;

 TInt drmDeCryptBufLen = 0;

	 if(iDRMOutBuf != NULL)

	 {

	  delete iDRMOutBuf;

	  iDRMOutBuf = NULL;

	 }

	drmDeCryptBufLen = iImageDataPtr.Size()+256;

	iDRMOutBuf = new (ELeave) TUint8[drmDeCryptBufLen];

     //One more byte than the original buffer for DRM code

	 inBufLen = iImageDataPtr.Size() + 1;

	 DRMInBuf = HBufC8::NewL(inBufLen + 1);

	 ptrInBuf.Set(DRMInBuf->Des() );

     ptrInBuf.Append(EView);

	 ptrInBuf.Append( (const TUint8 *) iImageDataPtr.Ptr(), iImageDataPtr.Size());

	 TPtr8 ptrOutBuf(iDRMOutBuf,0, drmDeCryptBufLen );

	 ContentAccess::CManager* manager = 

					   (ContentAccess::CManager*) NW_Ctx_Get(NW_CTX_CONT_ACCESS_MGR, 0);

	 manager->ListAgentsL( agents );

	 for (i = 0; i < agents.Count(); i++)

		{

		if (agents[i].Name().Compare(KOmaDrm2AgentName) == 0)

			{

			 agentDRM = agents[i];

			 break;

			}

		}

	  manager->AgentSpecificCommand( agentDRM, EBufferContainsOma1Dcf, 

									   iImageDataPtr ,ptrOutBuf, status);

	  User::WaitForRequest(status);

	  if(status == KErrNone)

		{

		//Now decrypt the buffer.

		 contentMgrErr = manager->AgentSpecificCommand( agentDRM, EDecryptOma1DcfBuffer, 

													 ptrInBuf,ptrOutBuf);

         if(contentMgrErr == KErrNone)

			{

			 iImageDataPtr.Set((const TUint8*) ptrOutBuf.Ptr(),ptrOutBuf.Size());

			 delete iImageConverter;

			 iImageConverter = NULL;

  			 TRAP(error, iImageConverter = CBufferedImageDecoder::NewL(iRfs))

             if(error == KErrNone)

			 {

			  TRAP(error, iImageConverter->OpenL(iImageDataPtr));

			 }

			} 

		  else

		  {

			error = contentMgrErr;

		  }

	   } 

	 agents.Close();

	 delete DRMInBuf;

     DRMInBuf = NULL;

 return error;

}

/*

 * Open

 *

 * Returns:

 *

 */

void CEpoc32ImageDecoder::Open()

    {

    TInt error = KErrNone;

    NW_LOG0(NW_LOG_LEVEL5, "CEpoc32ImageDecoder::Open started");

    if (iImageHasNotBeenOpened && iImage)

        {

        // inform the observer

        NW_Image_AbstractImage_ImageOpenStarted(NW_Image_AbstractImageOf(iImage));

        }

    // create image converter

    if (!iImageConverter)

        {

        // Symbian API requires a handle to RFs, but it is never used.

        // iRFs is not connected to the server

        iImageDataPtr.Set((const TUint8 *)NW_Image_Epoc32Simple_GetRawData(iImage),

                          NW_Image_Epoc32Simple_GetRawDataLength(iImage));

        if (iImage->imageType == EWbmpImage)

            {

            // We have a WBMP image

            TRAP(error, iImageConverter = CBufferedImageDecoder::NewL(iRfs))

                if (error == KErrNone)

                    {

                    TRAP(error, iImageConverter->OpenL(iImageDataPtr, KWbmpMimeType()));

					if(error != KErrNone)

					 {

                      error = CheckForDRMImage();

					 } /*end if(error != KErrNone)*/

                    }

            }/*end if (iImage->imageType == EWbmpImage)*/

        else if (iImage->imageType == EOtaImage)

            {

            // We have a OTA image