/*
* 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_*/