/* * Copyright (c) 2012-2017, Intel Corporation * * 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, sublicense, * 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 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 NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS 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. */ //! //! \file codechal_encode_jpeg.h //! \brief Defines the encode interface extension for JPEG. //! \details Defines all types, macros, and functions required by CodecHal for JPEG encoding. Definitions are not externally facing. //! #ifndef __CODECHAL_ENCODER_JPEG_H__ #define __CODECHAL_ENCODER_JPEG_H__ #include "codechal_encoder_base.h" //! //! \struct CodechalEncodeJpegHuffTable //! \brief Define the Huffman Table structure used by JPEG Encode //! struct CodechalEncodeJpegHuffTable { uint32_t m_tableClass; //!< table class uint32_t m_tableID; //!< table ID //This is the max size possible for these arrays, for DC table the actual occupied bits will be lesser // For AC table we need one extra byte to store 00, denoting end of huffman values uint8_t m_huffSize[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL + 1]; //!< Huffman size, occupies 1 byte in HW command uint16_t m_huffCode[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL + 1]; //!< Huffman code, occupies 2 bytes in HW command }; #pragma pack(push,1) //! //! \struct CodechalEncodeJpegFrameHeader //! \brief Define JPEG Frame Header structure //! struct CodechalEncodeJpegFrameHeader { uint16_t m_sof; //!< Start of frame marker uint16_t m_lf; //!< Frame header length uint8_t m_p; //!< Precision uint16_t m_y; //!< max number of lines in image uint16_t m_x; //!< max number of samples per line in image uint8_t m_nf; //!< Number of image components in the frame struct { uint8_t m_ci; //!< Component identifier uint8_t m_samplingFactori; //!< 4 MSBs are the horizontal and 4 LSBs are vertical sampling factors uint8_t m_tqi; //!< Quantization table selector (0-3) } m_codechalJpegFrameComponent[256]; //!< JPEG frame component array }; //! //! \struct CodechalJpegHuffmanHeader //! \brief Define JPEG Huffman Header structure //! struct CodechalJpegHuffmanHeader { uint16_t m_dht; //!< Define Huffman Table Marker uint16_t m_lh; //!< Huffman table definition length uint8_t m_tableClassAndDestn; //!< 4 bits of Huffman table class (0 = DC, 1 = AC) and 4 bits of destination identifier uint8_t m_li[JPEG_NUM_HUFF_TABLE_AC_BITS]; //!< List BITS of Huffman table uint8_t m_vij[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL]; //!< Value associated with each huffman code }; //! //! \struct CodechalEncodeJpegQuantHeader //! \brief Define JPEG Quant Header structure //! struct CodechalEncodeJpegQuantHeader { uint16_t m_dqt; //!< Define Quantization Marker uint16_t m_lq; //!< Quantization table definition length uint8_t m_tablePrecisionAndDestination; //!< 4 bits of element precision and 4 bits of destination selector uint8_t m_qk[JPEG_NUM_QUANTMATRIX]; //!< Quantization table elements }; //! //! \struct CodechalEncodeJpegRestartHeader //! \brief Define JPEG Restart Header structure //! struct CodechalEncodeJpegRestartHeader { uint16_t m_dri; //!< Define restart interval marker uint16_t m_lr; //!< Restart interval segment length uint16_t m_ri; //!< Restart interval }; //! //! \struct CodechalEncodeJpegScanComponent //! \brief JPEG Scan Component structure //! struct CodechalEncodeJpegScanComponent { uint8_t m_csj; //!< Scan component selector uint8_t m_tdaj; //!< 4 bits of DC huffman table destination selector and 4 bits of AC huffman table selector }; //! //! \struct CodechalEncodeJpegScanHeader //! \brief JPEG Scan Header structure //! struct CodechalEncodeJpegScanHeader { uint16_t m_sos; //!< Start of scan marker uint16_t m_ls; //!< Scan header length uint8_t m_ns; //!< Number of image components in scan CodechalEncodeJpegScanComponent m_scanComponent[jpegNumComponent]; uint8_t m_ss; //!< start of spectral selection uint8_t m_se; //!< end of spectral selection uint8_t m_ahl; //!< successive approximation bit position high and low }; #pragma pack(pop) //! JPEG Encoder State class //! //!This class defines the JPEG encoder state, it includes //!common member fields, functions, interfaces etc for all Gens. //! //!To create a JPEG encoder instance, client needs to call new(std::nothrow) CodechalEncodeJpegState(pEncoder) //! class CodechalEncodeJpegState : public CodechalEncoderState { public: //! //! \brief Constructor //! CodechalEncodeJpegState( CodechalHwInterface* hwInterface, CodechalDebugInterface* debugInterface, PCODECHAL_STANDARD_INFO standardInfo); //! //! \brief Destructor //! virtual ~CodechalEncodeJpegState() {}; //derived from base class MOS_STATUS Initialize(CodechalSetting *settings) override; MOS_STATUS AllocateResources() override; void FreeResources() override; MOS_STATUS InitializePicture(const EncoderParams& params) override; virtual MOS_STATUS CheckResChangeAndCsc() override; MOS_STATUS ExecutePictureLevel() override; MOS_STATUS ExecuteSliceLevel() override; uint32_t CalculateCommandBufferSize() override; virtual MOS_STATUS GetStatusReport( EncodeStatus* encodeStatus, EncodeStatusReport* encodeStatusReport) override; MOS_STATUS ExecuteKernelFunctions() override { return MOS_STATUS_SUCCESS;}; #if USE_CODECHAL_DEBUG_TOOL MOS_STATUS DumpQuantTables( CodecEncodeJpegQuantTable *quantTable); MOS_STATUS DumpPicParams( CodecEncodeJpegPictureParams *picParams); MOS_STATUS DumpScanParams( CodecEncodeJpegScanHeader *scanParams); MOS_STATUS DumpHuffmanTable( CodecEncodeJpegHuffmanDataArray *huffmanTable); #endif // Variables static const uint32_t m_jpegEncodeSoi = 0xFFD8; //!< JPEG Encode Header Markers SOI static const uint32_t m_jpegEncodeSos = 0xFFDA; //!< JPEG Encode Header Markers SOS // Parameters passed by application CodecEncodeJpegPictureParams *m_jpegPicParams = nullptr; //!< Pointer to picture parameter CodecEncodeJpegScanHeader *m_jpegScanParams = nullptr; //!< Pointer to scan parameter CodecEncodeJpegQuantTable *m_jpegQuantTables = nullptr; //!< Pointer to quant tables CodecEncodeJpegHuffmanDataArray *m_jpegHuffmanTable = nullptr; //!< Pointer to Huffman table void *m_applicationData = nullptr; //!< Pointer to Application data CODEC_REF_LIST *m_refList[CODECHAL_NUM_UNCOMPRESSED_SURFACE_JPEG]; //!< Pointer to reference pictures, added for eStatus reporting // Other uint32_t m_appDataSize = 0; //!< Pointer to Application data size bool m_jpegQuantMatrixSent = false; //!< JPEG: bool to tell if quant matrix was sent by the app or not bool m_fullHeaderInAppData = false; protected: //! //! \brief Map Huffman value index, implemented based on table K.5 in JPEG spec. //! //! \param [in] huffValIndex //! Huffman Value Index //! //! \return The mapped index //! uint8_t MapHuffValIndex(uint8_t huffValIndex); //! //! \brief Generate table of Huffman code sizes, implemented based on Flowchart in figure C.1 in JPEG spec //! //! \param [in] bits //! Contains the number of codes of each size //! \param [out] huffSize //! Huffman Size table //! \param [out] lastK //! Index of the last entry in the table //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS GenerateSizeTable( uint8_t bits[], uint8_t huffSize[], uint8_t& lastK); //! //! \brief Generate table of Huffman codes, implemented based on Flowchart in figure C.2 in JPEG spec //! //! \param [in] huffSize //! Huffman Size table //! \param [out] huffCode //! Huffman Code table //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS GenerateCodeTable( uint8_t huffSize[], uint16_t huffCode[]); //! //! \brief Generate Huffman codes in symbol value order, implemented based on Flowchart in figure C.3 in JPEG spec //! //! \param [in] huffVal //! Huffman Value table //! \param [in, out] huffSize //! Huffman Size table //! \param [in, out] huffCode //! Huffman Code table //! \param [in] lastK //! Index of the last entry in the table //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS OrderCodes( uint8_t huffVal[], uint8_t huffSize[], uint16_t huffCode[], uint8_t lastK); //! //! \brief Convert Huffman data to table, including 3 steps: Step 1 - Generate size table, Step2 - Generate code table, Step 3 - Order codes. //! //! \param [in] huffmanData //! Huffman Data //! \param [out] huffmanTable //! Huffman table //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS ConvertHuffDataToTable( CodecEncodeJpegHuffData huffmanData, CodechalEncodeJpegHuffTable *huffmanTable); //! //! \brief Pack SOI //! //! \param [out] buffer //! Bitstream buffer //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS PackSOI(BSBuffer *buffer); //! //! \brief Pack Application Data //! //! \param [out] buffer //! Bitstream buffer //! \param [in] appDataChunk //! Application Data Chunk //! \param [in] size //! Application Data Size //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS PackApplicationData( BSBuffer *buffer, uint8_t *appDataChunk, uint32_t size); //! //! \brief Pack Frame Header //! //! \param [out] buffer //! Bitstream buffer //! \param [in] useSingleDefaultQuantTable //! The flag of using single default Quant Table //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS PackFrameHeader( BSBuffer *buffer, bool useSingleDefaultQuantTable); //! //! \brief Pack Huffman Table //! //! \param [out] buffer //! Bitstream buffer //! \param [in] tableIndex //! The Huffman Table Index //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS PackHuffmanTable( BSBuffer *buffer, uint32_t tableIndex); //! //! \brief Pack Quant Table //! //! \param [out] buffer //! Bitstream buffer //! \param [in] componentType //! The Component Type //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS PackQuantTable( BSBuffer *buffer, CodecJpegComponents componentType); //! //! \brief Pack Restart Interval //! //! \param [out] buffer //! Bitstream buffer //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS PackRestartInterval( BSBuffer *buffer); //! //! \brief Pack Scan Header //! //! \param [out] buffer //! Bitstream buffer //! //! \return MOS_STATUS //! MOS_STATUS_SUCCESS if success, else fail reason //! MOS_STATUS PackScanHeader( BSBuffer *buffer); }; #endif //__CODECHAL_ENCODER_JPEG_H__