/* * 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 * */ #ifndef _PNW_HOST_JPEG_H_ #define _PNW_HOST_JPEG_H_ #include #define QUANT_TABLE_SIZE_BYTES (64) //! 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_*/