/*
 * Copyright (c) 2011 Intel Corporation. All Rights Reserved.
 * Copyright (c) Imagination Technologies Limited, UK
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *    Elaine Wang <elaine.wang@intel.com>
 *
 */


#ifndef _PNW_HOST_JPEG_H_
#define _PNW_HOST_JPEG_H_

#include <img_types.h>

#define QUANT_TABLE_SIZE_BYTES  (64)             //!<JPEG input quantization table size

#define MTX_MAX_COMPONENTS              (3)                             //<!JPEG input parameter sizes

#define PNW_JPEG_COMPONENTS_NUM (3)

#define PNW_JPEG_HEADER_MAX_SIZE (1024)
/*Limit the scan size to maximum useable (due to it being used as the
 * 16 bit field for Restart Intervals) = 0xFFFF MCUs
 * In reality, worst case allocatable bytes is less than this, something
 * around 0x159739C == 0x4b96 MCUs = 139 x 139 MCUS = 2224 * 2224 pixels, approx.
 * We'll give this upper limit some margin for error, and limit our
 * MCUsPerScan to 2000 * 2000 pixels = 125 * 125 MCUS = 0x3D09 MCUS
 * = 0x116F322 bytes (1170 worst case per MCU)*/
#define JPEG_MAX_MCU_PER_SCAN 0x3D09

#define JPEG_MCU_NUMBER(width, height, eFormat) \
    ((((width) + 15) / 16) * (((height) + 15) / 16) * \
     (((eFormat) == IMG_CODEC_YV16) ? 2 : 1))

#define JPEG_MCU_PER_CORE(width, height, core, eFormat) \
        ((core) > 1 ? (((uint32_t)JPEG_MCU_NUMBER(width, height, eFormat) + (core) - 1) / (core))\
         :(uint32_t)JPEG_MCU_NUMBER(width, height, eFormat))

#define JPEG_SCANNING_COUNT(width, height, core, eFormat) \
    ((uint32_t)(JPEG_MCU_PER_CORE(width, height, core, eFormat) > JPEG_MAX_MCU_PER_SCAN) ? \
      ((uint32_t)(JPEG_MCU_NUMBER(width, height, eFormat) + JPEG_MAX_MCU_PER_SCAN - 1) \
        / JPEG_MAX_MCU_PER_SCAN) \
       : (core))

#define JPEG_MCU_PER_SCAN(width, height, core, eFormat) \
    ((JPEG_MCU_PER_CORE(width, height, core, eFormat) > JPEG_MAX_MCU_PER_SCAN) ? \
    JPEG_MAX_MCU_PER_SCAN : JPEG_MCU_PER_CORE(width, height, core, eFormat))

/*The start address of every segment must align 128bits -- DMA burst width*/
#define JPEG_CODED_BUF_SEGMENT_SIZE(total, width, height, core, eFormat) \
    (((total) - PNW_JPEG_HEADER_MAX_SIZE) / \
     JPEG_SCANNING_COUNT(ctx->Width, ctx->Height, ctx->NumCores, eFormat) \
     & (~0xf))

/*pContext->sScan_Encode_Info.ui32NumberMCUsToEncodePerScan=(pContext->sScan_Encode_Info.ui32NumberMCUsToEncode+pEncContext->i32NumCores-1)/pEncContext->i32NumCores;
 *pContext->sScan_Encode_Info.aBufferTable[ui8Loop].ui32DataBufferSizeBytes = (DATA_BUFFER_SIZE(pContext->sScan_Encode_Info.ui32NumberMCUsToEncodePerScan) +sizeof(BUFFER_HEADER)) + 3 & ~3;
 ui32NumberMCUsToEncode is equal (width/16) * (height/16)
 MAX_MCU_SIZE is 1170
 For 352x288, size of data buffer is 231676.
 The number of data buffer is equal to the number of cores minus one*/
#define PNW_JPEG_CODED_BUF_SIZE(width, height, NumCores)  ((((((width) + 15) / 16) * (((height) + 15) / 16) * MAX_MCU_SIZE ) + 0xf) & ~0xf)


typedef struct {
    unsigned int        ui32Width;              //!< Width of the image component
    unsigned int        ui32Stride;             //!< Stride of the image component
    unsigned int        ui32Step;               //!< Step of the image component
    unsigned int        ui32Height;             //!< Height of the image component

} COMP_INFO;

typedef struct {
    unsigned int        ui32OutputWidth;                //!< Width of the JPEG image
    unsigned int        ui32OutputHeight;               //!< Height of the JPEG image
    unsigned int        ui32Components;                 //!< Number of components in the image ( 1 or 3 )
    COMP_INFO   sCompInfo[3];                   //!< Array containing component info

} IMG_JPEG_INFO;

typedef enum _img_format_ {
    IMG_CODEC_IYUV, /* IYUV */
    IMG_CODEC_IMC2, /* IMC2 */
    IMG_CODEC_PL8,
    IMG_CODEC_PL12,
    IMG_CODEC_NV12,
    IMG_CODEC_YV16,
} IMG_FORMAT;

typedef struct {
    IMG_UINT32  ui32BytesUsed;          //!<
    IMG_UINT32  ui32BytesEncoded;       //!<
    IMG_UINT32  ui32BytesToEncode;      //!<
    IMG_UINT32  ui32Reserved3;          //!<

} BUFFER_HEADER;

typedef enum {
    IMG_ERR_OK                                  = 0,    //!< OK
    IMG_ERR_SURFACE_LOCKED              = 1,    //!< The requested surface was locked
    IMG_ERR_MEMORY                              = 2,    //!< A memory error occured
    IMG_ERR_FILE                                = 3,    //!< A file error occured
    IMG_ERR_NOBUFFERAVAILABLE   = 4,    //!< No buffer was available
    IMG_ERR_COMPLETE                    = 5,    //!< Command is complete
    IMG_ERR_INVALID_CONTEXT             = 6,    //!< An invalid context was given
    IMG_ERR_INVALID_SIZE                = 7,    //!< An invalid size was given
    IMG_ERR_TIMEOUT                             = 8,    //!< Timeout
    IMG_ERR_UNDEFINED                   = -1

} IMG_ERRORCODE;

/*!
 *  *****************************************************************************
 *
 * @details    Struct sent with the MTX_CMDID_ISSUEBUFF command detailing
 *                                 where a scan encode should begin (calculated from the total count of MCUs)
 *                                 and how many MCU's should be processed in this scan.
 *
 * @brief          JPEG structure defining scan start position and how many MCUs to process
 *
 ****************************************************************************/
typedef struct {
    IMG_UINT32  ui32CurrentMTXScanMCUPosition;  //!< Scan start position in MCUs
    IMG_UINT32  ui32MCUCntAndResetFlag;         //!< [32:2] Number of MCU's to encode or decode, [1] Reset predictors (1=Reset, 0=No Reset)

} MTX_ISSUE_BUFFERS;
/*!
 *  *****************************************************************************
 *
 * @details    Struct describing surface component info
 *
 * @brief          Surface component info
 *
 *****************************************************************************/
typedef struct {
    IMG_UINT32 ui32Step;
    IMG_UINT32 ui32Width;
    IMG_UINT32 ui32Height;
    IMG_UINT32 ui32PhysWidth;
    IMG_UINT32 ui32PhysHeight;

} IMG_SURF_COMPONENT_INFO;

/*!
 *  *****************************************************************************
 *
 * @details    Enum describing buffer lock status
 *
 * @brief          Buffer lock status
 *
 ****************************************************************************/
typedef enum {
    BUFFER_FREE = 1,  //!< Buffer is not locked
    HW_LOCK,          //!< Buffer is locked by hardware
    SW_LOCK,          //!< Buffer is locked by software
    NOTDEVICEMEMORY,    //!< Buffer is not a device memory buffer
} LOCK_STATUS;


/*!v
 *  *****************************************************************************
 *
 * @details    Struct describing a coded data buffer
 *
 * @brief          Coded data buffer
 *
 * ****************************************************************************/
typedef struct {
    void* pMemInfo;   //!< Pointer to the memory handle for the buffer
    LOCK_STATUS sLock;                  //!< Lock status for the buffer
    IMG_UINT32  ui32Size;               //!< Size in bytes of the buffer
    IMG_UINT32  ui32BytesWritten;       //!< Number of bytes written into buffer
} IMG_BUFFER, IMG_CODED_BUFFER;


/*!
 *  *****************************************************************************
 *
 * @details    Struct describing a frame
 *
 * @brief          Frame information
 *
 ****************************************************************************/
typedef struct {
    IMG_BUFFER *psBuffer;                           //!< pointer to the image buffer
    IMG_UINT32 ui32Width;                                                       //!< stride of pBuffer
    IMG_UINT32 ui32Height;                                                      //!< height of picture in pBuffer

    IMG_UINT32 ui32ComponentCount;                                      //!< number of colour components used
    IMG_FORMAT eFormat;                                                         //!< Format of the surface

    IMG_UINT32  aui32ComponentOffset[3];                        //!< Offset of the planes within the surface
    IMG_SURF_COMPONENT_INFO     aui32ComponentInfo[3];  //!< Component plane information

} IMG_FRAME, JPEG_SOURCE_SURFACE;
#define MAX_NUMBER_OF_MTX_UNITS 4 // Number of MTX units
/* Number of buffers for encode coded data*/
#define NUMBER_OF_BUFFS 3 // Should be at least equal to number of MTX's for optimal performance
#define SIM_TEST_NUMBER_OF_BUFFS 3 // Should be at least equal to number of MTX's for optimal performance
#define BLOCKCOUNTMAXPERCOLOURPLANE 6 // Would be 10 for max theoretically possible.. 6 is our actual max
#define MAX_MCU_SIZE                    (((8*8)+1)*3 * BLOCKCOUNTMAXPERCOLOURPLANE)
#define SIM_TEST_MCUS_IN_BUFFER 22
#define RL_END_OF_BLOCK         0xff
#define DATA_BUFFER_SIZE(mcus_in_buffer) (MAX_MCU_SIZE*mcus_in_buffer)
#define DMEMORYMCUSATSIXSEVENTY_ESTIMATE 55488

#define C_INTERLEAVE 1
#define LC_UVINTERLEAVE 2
#define LC_VUINTERLEAVE 3

//#define ISCHROMAINTERLEAVED(eSurfaceFormat) ((IMG_UINT) (eSurfaceFormat==IMG_CODEC_Y0UY1V_8888)*LC_UVINTERLEAVE)+((IMG_UINT) (eSurfaceFormat==IMG_CODEC_Y0VY1U_8888)*LC_VUINTERLEAVE)+((IMG_UINT) (eSurfaceFormat==IMG_CODEC_PL12 || eSurfaceFormat==IMG_CODEC_422_PL12)*C_INTERLEAVE)

#define ISCHROMAINTERLEAVED(eSurfaceFormat) ((IMG_UINT) (eSurfaceFormat==IMG_CODEC_PL12 || eSurfaceFormat==IMG_CODEC_NV12)*C_INTERLEAVE)
/*****************************************************************************/
/*  \brief   MAX_COMP_IN_SCAN                                                */
/*                                                                           */
/*  Maximum components that can be encoded in a scan as specified by the     */
/*  JPEG specification.                                                      */
/*****************************************************************************/
#define MAX_COMP_IN_SCAN                4
//#define MTX_CMD_BUF_SIZE      (32)
//#define MTX_MAX_COMPONENTS    (3)
#define PERF            1

/******************************************************************************
  General definitions for static header offsets (used for MJPEG A headers)
 ******************************************************************************/
#define H_QT_OFFSET 46
#define H_HT_OFFSET 184
#define H_SOF_OFFSET 622
#define H_SOS_OFFSET 642
#define H_SOI_OFFSET 656


/******************************************************************************
  General definitions
 ******************************************************************************/
#define BYTE                            8
#define BYTES_IN_INT                    4
#define BITS_IN_INT                     32
#define BLOCK_SIZE                      8
#define PELS_IN_BLOCK                   64

/******************************************************************************
  MJPEG A marker definitions
 ******************************************************************************/
#define MJPEG_APP1                                      0xFFE1

/******************************************************************************
  JPEG marker definitions
 ******************************************************************************/
#define START_OF_IMAGE              0xFFD8
#define SOF_BASELINE_DCT            0xFFC0
#define END_OF_IMAGE                0xFFD9
#define START_OF_SCAN               0xFFDA


/* Definitions for the huffman table specification in the Marker segment */
#define DHT_MARKER                  0xFFC4
#define LH_DC                       0x001F
#define LH_AC                       0x00B5
#define LEVEL_SHIFT                 128

/* Definitions for the quantization table specification in the Marker segment */
#define DQT_MARKER                  0xFFDB
#define ACMAX                       0x03FF
#define DCMAX                       0x07FF
/* Length and precision of the quantization table parameters */
#define LQPQ                        0x00430
#define QMAX                        255
#define CLIP(Number,Max,Min)    if((Number) > (Max)) (Number) = (Max); \
    else if((Number) < (Min)) (Number) = (Min)
#define AVAILABLE                       ( 0 )
#define JPEG_ENCODE_LOCK        ( 0x20 )


//////////////////////////////////////////////////////////////////////////////////////////////
// Structures unchanged by TopazSc
//////////////////////////////////////////////////////////////////////////////////////////////

//typedef struct
//{
//      IMG_UINT32 ui32BytesUsed;
//      IMG_UINT32 ui32BytesEncoded;
//      IMG_UINT32 ui32Reserved2;
//      IMG_UINT32 ui32Reserved3;
//} BUFFER_HEADER;

/*****************************************************************************/
/*  STREAMTYPEW                                                                          */
/*  Container to store the stream context                                    */
/*****************************************************************************/
typedef struct {
    IMG_UINT8 *Buffer; /*!< Ptr to the bitstream buffer */
    IMG_UINT32 Offset;  /*!< Offset in the bitstream buffer */
    IMG_UINT32 Limit;
} STREAMTYPEW;

//typedef struct
//{
//      IMG_UINT32 ui32WidthBlocks ;    /* Width in pixels, shall be a multiple of 8*/
//      IMG_UINT32 ui32HeightBlocks ;   /* Height in pixels, shall be a multiple of 8*/
//      IMG_UINT32 ui32XLimit;                  /* Blocks will not be encoded beyond this */
//      IMG_UINT32 ui32YLimit;                  /* Blocks will not be encoded beyond this */
//} MCUCOMPONENT;
//
//typedef struct
//{
//      IMG_UINT32 ui32PhysAddr;                /* Physical address Component plane in shared memory*/
//      IMG_UINT32 ui32Stride;                  /* Stride of source plane */
//      IMG_UINT32 ui32Height;                  /* Height of avaliable data in plane.  shall be a minumum of one MCU high */
//} COMPONENTPLANE;
//
//
//typedef struct
//{
///// The following values are DMA'd straight across from host
//      COMPONENTPLANE  ComponentPlane[MTX_MAX_COMPONENTS];
//      MCUCOMPONENT    MCUComponent[MTX_MAX_COMPONENTS];
//      IMG_UINT32 ui32ComponentsInScan;        /* Number of compnents */
//      IMG_UINT32 ui32TableA;          /* Quantisation table for Luma component*/
//      IMG_UINT32 ui32DataInterleaveStatus; /*What kind of interleaving is required*/
//} JPEG_MTX_DMA_SETUP;


//typedef struct
//{
////    IMG_UINT32  ui32BufferPhysAddr;         /*  Physical address of buffer table in shared memory*/
//      IMG_UINT32  ui32CurrentMTXScanMCUPosition; // Scan start position in MCUs
//    IMG_UINT32  ui32SizeAndProcMCUCount;/*    [31:16] Valid data in bytes
//                                                                                      [15:0] Number of MCU's to encode or decode */
//} MTX_ISSUE_BUFFERS;


//////////////////////////////////////////////////////////////////////////////////////////////
// Old Topaz structures (retained for backward compatibility with sim tests)
//////////////////////////////////////////////////////////////////////////////////////////////

typedef struct {
    IMG_UINT32 ui32BytesPendingEDMA;
    IMG_UINT32 ui32BytesEncoded;
    IMG_UINT32 ui32BlocksEncoded;
} LEGACY_ENCODE_HEADER;

typedef enum {
    BUFF_BUSY_IN_HW_0,  /* Indicates that this buffer is in use by the hardware */
    BUFF_BUSY_IN_SW,    /* Indicates that this buffer is in use by sw */
    BUFF_AVALIABLE,             /* Indicates this buffer can be submitted to hw */
} LEGACY_BUFFER_STATUS;

/*****************************************************************************/
/*  \brief   _EncType                                                        */
/*                                                                           */
/*  JPEG low level encoder context structure                                           */
/*****************************************************************************/
typedef struct {
    //    STREAMTYPEW streamW;    /*!< Ptr to the stream context */
    const IMG_UINT16 *ACCode[2];     /*!< Ptr to the huffman tables to code AC coeffs */
    const IMG_UINT8  *ACSize[2];     /*!< Ptr to the huffman tables to code AC coeffs */
    const IMG_UINT16 *DCCode[2];     /*!< Ptr to the huffman tables to code DC coeffs */
    const IMG_UINT8  *DCSize[2];     /*!< Ptr to the huffman tables to code DC coeffs */

    IMG_UINT8  *Qmatrix[MAX_COMP_IN_SCAN];/*!< Ptr to the Quant tables */
    IMG_UINT8  uc_num_mcu_x;   /*!< Number of MCUs in the horizontal direction */
    IMG_UINT8  uc_num_mcu_y;   /*!< Number of MCUs in the vertical direction */

    IMG_UINT8  aui8QuantTable[MAX_COMP_IN_SCAN][64]; /* Area for creating tables */
} LEGACY_ENCTYPE;

typedef struct {
    IMG_UINT8*  pData;
    IMG_UINT32  ui32DataBufferSize;
    IMG_UINT32  OpNum;
    IMG_UINT32  ui32numberOfMCUs;
    LEGACY_BUFFER_STATUS        eBufferStatus;
    struct MEMORY_INFO_TAG* pMemInfo;

    IMG_UINT32  ui32CurrentIndexAccessPos;
    IMG_UINT32  ui32CurrentIndexHeaderPos;
#ifdef PERF
    IMG_UINT32  ui32IssueTime;
#endif

} LEGACY_BUFFERINFO;


/*****************************************************************************/
/*  LEGACY_JPEGENC_ITTIAM_PARAMS                                                 */
/*                                                                           */
/*  Pointer to the JPEG encoder parameter context. This structure is used by */
/*  the sample application to pass configuration parameters to the encoder.  */
/*****************************************************************************/
typedef struct {
    IMG_UINT8  uc_num_q_tables;        /*!< Number of Q tables */
    IMG_UINT16 ui16_q_factor;          /*!< Quality factor */
    IMG_UINT8  puc_q_table_id[4];      /*!< Q table ID */
    IMG_UINT8  puc_q_table[4][64];     /*!< Q tables */
    IMG_UINT8  uc_isAbbreviated;       /*!< 0: Interchange ; 1: Abbreviated */
    IMG_UINT8  uc_num_comp_in_scan;    /*!< Number of components in scan (<= 3) */
    IMG_UINT8  puc_comp_id[MAX_COMP_IN_SCAN]; /*!< Component identifier */
    IMG_UINT16 ui16_width;             /*!< Width of the JPEG image */
    IMG_UINT16 ui16_height;            /*!< Height of the JPEG image */
} LEGACY_JPEGENC_ITTIAM_PARAMS;

typedef struct {
    IMG_UINT8  uc_num_comp_in_img;    /*!< Number of components in image */
    IMG_UINT8  puc_comp_id[255];      /*!< Component identifier */
    IMG_UINT8  puc_q_table_id[255];   /*!< Q table id to use */
    IMG_UINT8  puc_huff_table_id[255];/*!< Huff table id to use */
    IMG_UINT8 *puc_comp_buff[255];    /*!< Ptr to the component buff */
    IMG_UINT16 pui16_comp_width[255]; /*!< Width of the component buff */
    IMG_UINT16 pui16_comp_height[255];/*!< Height of the component buff */
    IMG_UINT8  puc_horiz_scale[MAX_COMP_IN_SCAN];/*!< Component horizontal scale factor */
    IMG_UINT8  puc_vert_scale[MAX_COMP_IN_SCAN]; /*!< Component vertical scale factor */

    IMG_UINT8 CompIdtoIndex[MAX_COMP_IN_SCAN];

} LEGACY_JPEGENC_ITTIAM_COMPONENT;

typedef enum {
    LEGACY_JPEG_API_CURRENT_ACTIVE_NONE,
    LEGACY_JPEG_API_CURRENT_ACTIVE_ENCODE,
    LEGACY_JPEG_API_CURRENT_ACTIVE_DECODE,

} LEGACY_JPEG_API_CURRENT_ACTIVE;


/*!
 *  *****************************************************************************
 *
 * @details    Struct describing Minimum Coded Unit information for a single JPEG component plane.
 *  Details the size of blocks to be taken from the plane and the maximum block positions.
 *  Send to firmware in the MTX_CMDID_SETUP command as part of the JPEG_MTX_DMA_SETUP structure
 *
 * @brief          JPEG Minimum Coded Unit Information
 *
 *****************************************************************************/
typedef struct {
    IMG_UINT32  ui32WidthBlocks;        //!< Width in pixels, shall be a multiple of 8
    IMG_UINT32  ui32HeightBlocks;       //!< Height in pixels, shall be a multiple of 8
    IMG_UINT32  ui32XLimit;                     //!< Blocks will not be encoded beyond this
    IMG_UINT32  ui32YLimit;                     //!< Blocks will not be encoded beyond this

} MCUCOMPONENT;


/*!
 *  *****************************************************************************
 *
 *   @details    Struct describing essential information about a single JPEG component plane, defines the
 *         Physical address of the colour plane, its stride and its height.
 *      Send to firmware in the MTX_CMDID_SETUP command as part of the JPEG_MTX_DMA_SETUP structure.
 *
 *   @brief          Basic information for a single JPEG component plane, passed to firmware.
 *
 *****************************************************************************/
typedef struct {
    IMG_UINT32  ui32PhysAddr;   //!< Physical address Component plane in shared memory
    IMG_UINT32  ui32Stride;             //!< Stride of source plane */
    IMG_UINT32  ui32Height;             //!< Height of avaliable data in plane.  shall be a minumum of one MCU high

} COMPONENTPLANE;


/*!
 *  *****************************************************************************
 *
 *  @details    Struct describing essential information required by firmware to encode a scan.
 *         Send to firmware in the MTX_CMDID_SETUP command.
 *
 *  @brief          Setup information for a single JPEG scan.
 *
 *****************************************************************************/
typedef struct {
    COMPONENTPLANE      ComponentPlane[MTX_MAX_COMPONENTS];     //!< Array of component plane source information (detailing physical address, stride and height)
    MCUCOMPONENT        MCUComponent[MTX_MAX_COMPONENTS];       //!< Array of Minimum Coded Unit information for each component plane
    IMG_UINT32          ui32ComponentsInScan;                           //!< Number of components
    IMG_UINT32          ui32TableA;                                                     //!< Quantisation table for Luma component
    IMG_UINT32          ui32DataInterleaveStatus;                       //!< Source component interleave status (0, C_INTERLEAVE, LC_UVINTERLEAVE or LC_VUINTERLEAVE)

} JPEG_MTX_DMA_SETUP;

/* JPEG HW Interface state structure */
typedef struct {
    struct MEMORY_INFO_TAG* pMemInfoMTXSetup;
    JPEG_MTX_DMA_SETUP* pMTXSetup;

    struct MEMORY_INFO_TAG* pMemInfoTableBlock;
    IMG_UINT8           *pui8TablesBlock;

    LEGACY_ENCODE_HEADER* pLastEncodeHeader;

    LEGACY_BUFFERINFO           asRLCBuffers[SIM_TEST_NUMBER_OF_BUFFS];

    IMG_UINT8*          pLocalMemBuffer;

    IMG_UINT32          ui32CurrentIndex;

    /* These are used by by encode */
    IMG_UINT32          rlcWriteIndex;
    IMG_UINT32          rlcReadIndex;

    /* It would be nice to get rid of this */
    LEGACY_BUFFERINFO*  pCurrBuff;
    IMG_UINT8*          pReadFromRLE;

    IMG_UINT32          uiLastDCValue;

    IMG_BOOL bNeedRestart;

#ifdef PERF
    IMG_UINT32 ui32PendingBufferTime;
    IMG_UINT32 ui32ProccessDelay;
    IMG_UINT32 ui32TotalBytesTX;
    IMG_UINT32 ui32TotalTXTime;
#endif

} LEGACY_MTXJPEG_HOST_STATE;

typedef struct {
    LEGACY_JPEGENC_ITTIAM_PARAMS JPEGEncoderParams;
    LEGACY_JPEGENC_ITTIAM_COMPONENT sJPEGEncoderComp;
    IMG_UINT32 BytesUsed;
    IMG_UINT8* pui8ByteBuffer;
    IMG_JPEG_INFO       sJpegInfo ;
    LEGACY_ENCTYPE*     pvLowLevelEncContext;
    LEGACY_JPEG_API_CURRENT_ACTIVE      eCurrentActive;
    struct MEMORY_INFO_TAG *pHWSync;
    LEGACY_MTXJPEG_HOST_STATE* gpMTXHostState;
    IMG_UINT32 ui32MCUsWaitingToBeSentToHW;
    IMG_UINT32 ui32MCUsPendingHWEnc;
    IMG_UINT32 ui32BlocksHWEncoded;
    IMG_UINT8 ui32JPEGBytesWritten;
    IMG_UINT32 MCUsToDo;
    IMG_UINT16 ui16Quality;
    IMG_HANDLE ui32Handles[MTX_MAX_COMPONENTS];
    IMG_UINT32 ui32Offsets[MTX_MAX_COMPONENTS];
    JPEG_SOURCE_SURFACE sSurf;

} LEGACY_JPEG_ENCODER_CONTEXT;


//////////////////////////////////////////////////////////////////////////////////////////////
// New TopazSc structures
//////////////////////////////////////////////////////////////////////////////////////////////

typedef struct {
    unsigned char * pMemInfo;
    IMG_UINT16 ui16ScanNumber;
    IMG_UINT32 ui32WriteBackVal;
    IMG_INT8 i8MTXNumber; // Doubles as status indicator ( <0 = Awaiting output to CB, 0 = Idle, >0 = Being filled by MTX)
    IMG_UINT32  MTXOpNum; // Handle returned from MTX issuebuff command, can be used to check for completion
    IMG_UINT32 ui32DataBufferSizeBytes;
    IMG_UINT32 ui32DataBufferUsedBytes;
} TOPAZSC_JPEG_BUFFER_INFO;

typedef struct {
    IMG_UINT16 ui16CScan; /*The number of scans to be done, ui32NumberMCUsToEncode / ui32NumberMCUsToEncodePerScan*/
    IMG_UINT16 ui16SScan; /*The current index of scan*/
    IMG_UINT16 ui16ScansInImage;
    IMG_UINT8 ui8MTXIdleCnt;
    IMG_UINT8 aui8MTXIdleTable[MAX_NUMBER_OF_MTX_UNITS];
    TOPAZSC_JPEG_BUFFER_INFO *aBufferTable;
    IMG_UINT32 ui32NumberMCUsX; /* Width / 16*/
    IMG_UINT32 ui32NumberMCUsY; /* Height / 16*/
    IMG_UINT32 ui32NumberMCUsToEncode; /*Total number of MCUs to encode*/
    IMG_UINT32 ui32NumberMCUsToEncodePerScan; /*Number of MCUs per scan, should be  ui32NumberMCUsX * ui32NumberMCUsY*/
    IMG_UINT8 ui8NumberOfCodedBuffers;
    IMG_UINT32 ui32CurMCUsOffset;
} TOPAZSC_SCAN_ENCODE_INFO;

typedef struct {
    IMG_UINT8   aui8LumaQuantParams[QUANT_TABLE_SIZE_BYTES];    //!< Luma quant params
    IMG_UINT8   aui8ChromaQuantParams[QUANT_TABLE_SIZE_BYTES];  //!< Chroma quant params

} JPEG_MTX_QUANT_TABLE;

typedef struct context_jpeg_ENC_s {

    IMG_FORMAT eFormat;
    /*IMG_UINT16 ui16Quality;*/
    IMG_UINT32 ui32OutputWidth;
    IMG_UINT32 ui32OutputHeight;
    IMG_UINT32 ui32InitialCBOffset;

    object_surface_p pSourceSurface;
    unsigned char * pMemInfoMTXSetup;
    JPEG_MTX_DMA_SETUP* pMTXSetup;

    unsigned char * pMemInfoTableBlock;
    JPEG_MTX_QUANT_TABLE        *psTablesBlock;

    IMG_UINT32 ui32Offsets[MTX_MAX_COMPONENTS];

    TOPAZSC_SCAN_ENCODE_INFO sScan_Encode_Info;

    IMG_CODED_BUFFER jpeg_coded_buf;

    unsigned char *ctx;
    IMG_UINT32 ui32SizePerCodedBuffer;
    IMG_UINT8  ui8ScanNum;
} TOPAZSC_JPEG_ENCODER_CONTEXT;

//////////////////////////////////////////////////////
//Function Declarations unchanged by TopazSC
//////////////////////////////////////////////////////
int customize_quantization_tables(unsigned char *luma_matrix,
                                  unsigned char *chroma_matrix,
                                  unsigned int ui32Quality);

void SetCompInfoFromFormat(IMG_FORMAT eFormat, IMG_UINT32 ui32Width, IMG_UINT32 ui32Height, IMG_JPEG_INFO       *psJpegInfo);
/* This function will copy data from one buffer to another where the destination has a different stride */
void APP_CopyToWithStride(IMG_UINT8* pSrc, IMG_UINT8* pDest , IMG_UINT32 ui32SrcWidth, IMG_UINT32 ui32SrcPhysWidth, IMG_UINT32 ui32SrcStep, IMG_UINT32 ui32SrcHeight, IMG_UINT32 ui32DestPhysWidth, IMG_UINT32 ui32DestPhysHeight);
IMG_ERRORCODE SetupJPEGSourceSurface(IMG_FORMAT eSurfaceFormat, IMG_UINT32 ui32FrameWidth, IMG_UINT32 ui32FrameHeight, JPEG_SOURCE_SURFACE *pSurf);
//void FlushByteAlignedBuffer(IMG_UINT32 *pui_buff, IMG_UINT32 *ui_bytes_to_flush, FILE *pf_out);

//////////////////////////////////////////////////////
//Legacy function declarations - most of these will eventually be removed
//////////////////////////////////////////////////////
IMG_ERRORCODE Legacy_PrepareHeader(LEGACY_JPEG_ENCODER_CONTEXT * pContext, IMG_CODED_BUFFER *pCBuffer);
//IMG_ERRORCODE Legacy_AllocateCodedDataBuffers(LEGACY_JPEG_ENCODER_CONTEXT *pContext);
//IMG_ERRORCODE Legacy_host_InitialiseHardware(LEGACY_JPEG_ENCODER_CONTEXT *pContext);
//IMG_ERRORCODE Legacy_IMG_JPEG_EndPicture(IMG_HENC_CONTEXT hEncContext, IMG_CODED_BUFFER *pCBuffer);
//IMG_ERRORCODE Legacy_IMG_JPEG_FreeBuffer(LEGACY_JPEG_ENCODER_CONTEXT * pContext, IMG_CODED_BUFFER **ppCBuffer);
//IMG_ERRORCODE Legacy_IMG_JPEG_DeAllocateFrames(LEGACY_JPEG_ENCODER_CONTEXT *pContext,IMG_FRAME_ARRAY **pFrameArray);
//IMG_ERRORCODE Legacy_IMG_JPEG_EncoderInitialise(IMG_UINT16 ui16Width, IMG_UINT16 ui16Height, IMG_FORMAT eFormat, LEGACY_JPEG_ENCODER_CONTEXT ** ppContext);
//IMG_ERRORCODE Legacy_IMG_JPEG_EncoderDeInitialise(LEGACY_JPEG_ENCODER_CONTEXT * pContext);
//IMG_ERRORCODE Legacy_IMG_JPEG_AllocateFrames(LEGACY_JPEG_ENCODER_CONTEXT *pContext, IMG_UINT16 ui16ArraySize,IMG_FRAME_ARRAY **ppFrameArray);
//IMG_ERRORCODE Legacy_IMG_JPEG_AllocateCodedBuffer(LEGACY_JPEG_ENCODER_CONTEXT * pContext, IMG_UINT32 ui32CBufferSize, IMG_CODED_BUFFER **ppCBuffer);
//IMG_ERRORCODE Legacy_IMG_JPEG_StartPicture(IMG_HENC_CONTEXT hEncContext, IMG_UINT16 ui16Quality, IMG_CODED_BUFFER *pCBuffer,IMG_FRAME *pTFrame);

//////////////////////////////////////////////////////
//TopazSc Function Declarations
//////////////////////////////////////////////////////
IMG_ERRORCODE PrepareHeader(TOPAZSC_JPEG_ENCODER_CONTEXT * pContext, IMG_CODED_BUFFER *pCBuffer, IMG_UINT32 ui32StartOffset, IMG_BOOL bIncludeHuffmanTables);
IMG_ERRORCODE AllocateCodedDataBuffers(TOPAZSC_JPEG_ENCODER_CONTEXT *pContext);
//IMG_ERRORCODE IMG_JPEG_EndPicture(IMG_HENC_CONTEXT hEncContext, IMG_CODED_BUFFER *pCBuffer);
//IMG_ERRORCODE IMG_JPEG_FreeBuffer(TOPAZSC_JPEG_ENCODER_CONTEXT * pContext, IMG_CODED_BUFFER **ppCBuffer);
//IMG_ERRORCODE IMG_JPEG_DeAllocateFrames(TOPAZSC_JPEG_ENCODER_CONTEXT *pContext,IMG_FRAME_ARRAY **pFrameArray);
//IMG_ERRORCODE IMG_JPEG_EncoderInitialise(IMG_HENC_CONTEXT hEncContext,IMG_UINT16 ui16Width, IMG_UINT16 ui16Height, IMG_FORMAT eFormat, TOPAZSC_JPEG_ENCODER_CONTEXT ** ppContext);
//IMG_ERRORCODE IMG_JPEG_EncoderDeInitialise(TOPAZSC_JPEG_ENCODER_CONTEXT * pContext);
//IMG_ERRORCODE IMG_JPEG_AllocateFrames(TOPAZSC_JPEG_ENCODER_CONTEXT *pContext, IMG_UINT32 ui32ArraySize,IMG_FRAME_ARRAY **ppFrameArray);
IMG_ERRORCODE IMG_JPEG_AllocateCodedBuffer(IMG_UINT32 ui32CBufferSize, IMG_CODED_BUFFER **ppCBuffer);
//IMG_ERRORCODE IMG_JPEG_StartPicture(IMG_HENC_CONTEXT hEncContext, IMG_UINT16 ui16Quality, IMG_CODED_BUFFER *pCBuffer,IMG_FRAME *pTFrame, IMG_UINT32 ui32StartOffset, IMG_BOOL bIncludeHuffmanTables);

IMG_ERRORCODE InitializeJpegEncode(TOPAZSC_JPEG_ENCODER_CONTEXT * pContext, object_surface_p pTFrame);
IMG_ERRORCODE SetupJPEGTables(TOPAZSC_JPEG_ENCODER_CONTEXT * pContext, IMG_CODED_BUFFER *pCBuffer,  object_surface_p pTFrame);
IMG_ERRORCODE SubmitScanToMTX(TOPAZSC_JPEG_ENCODER_CONTEXT *pContext, IMG_UINT16 ui16BCnt, IMG_INT8 i8MTXNumber, IMG_UINT32 ui32NoMCUsToEncode);
void pnw_jpeg_set_default_qmatix(unsigned char *pMemInfoTableBlock);
void fPutBitsToBuffer(STREAMTYPEW *BitStream, IMG_UINT8 NoOfBytes, IMG_UINT32 ActualBits);
#endif /*_HOST_JPEG_H_*/