/* SPDX-License-Identifier: LGPL-2.1 OR BSD-3-Clause */ /* * Copyright (c) 2018, Chips&Media * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef JPUAPI_H_INCLUDED #define JPUAPI_H_INCLUDED #ifdef USE_FEEDING_METHOD_BUFFER #include "codaj12/jpuapi/jpuconfig.h" #include "codaj12/jdi/jdi.h" #include "codaj12/jpuapi/jputypes.h" #else #include "jpuconfig.h" #include "../jdi/jdi.h" #include "jputypes.h" #endif /* _n: number, _s: significance */ #define JPU_CEIL(_s, _n) (((_n)+(_s-1))&~(_s-1)) #define JPU_FLOOR(_s, _n) (_n&~(_s-1)) //------------------------------------------------------------------------------ // common struct and definition //------------------------------------------------------------------------------ /** * @brief This is a special enumeration type for representing the JPEG profiles. */ typedef enum { /* Non-differential, Huffman coding */ JPEG_BASELINE_DCT, /**< JPEG baseline profile */ JPEG_EXTENDED_SEQUENTIAL_DCT, /**< JPEG extended sequential profile */ /* The others are not supported on CODAJ12 */ } JpgProfile; /** * @brief This is a special enumeration type for some configuration commands from host processor to the JPU. Most of these commands can be called occasionally, not periodically for changing the configuration of decoder operations running on the JPU. Details of these commands will be presented in the next chapter. */ typedef enum { SET_JPG_SCALE_HOR, /**< This command sets the scale down ratio for picture width. The scale ratio value can be either 1(1/2 scale), 2(1/4 scale) or 3(1/8 scale). */ SET_JPG_SCALE_VER, /**< This command sets the scale down ratio for picture height. The scale ratio value can be either 1(1/2 scale), 2(1/4 scale) or 3(1/8 scale). */ SET_JPG_USE_STUFFING_BYTE_FF, /**< This command sets use of stuffing byte, 0xFF. */ SET_JPG_QUALITY_FACTOR, /**< This command sets use of quality factor. */ ENC_JPG_GET_HEADER, /**< This command generates JPEG high-level header syntaxes. */ ENABLE_LOGGING, /**< This command activates message logging once JPU_DecOpen() or JPU_EncOpen() is called. */ DISABLE_LOGGING, /**< This command deactivates message logging. (default) */ JPG_CMD_END } JpgCommand; /** * @brief This is a type for representing physical addresses which is recognizable by the JPU. In general, the JPU hardware does not know about virtual address space which is set and handled by host processor. All these virtual addresses are translated into physical addresses by Memory Management Unit. All data buffer addresses such as stream buffer, frame buffer, should be given to the JPU as an address on physical address space. */ typedef enum { JPG_RET_SUCCESS, /**< This means that operation was done successfully. */ JPG_RET_FAILURE, /**< This means that operation was not done successfully. */ JPG_RET_BIT_EMPTY, /**< This means that bitstream buffer is found to be empty during decode operation. */ JPG_RET_EOS, /**< This means the end of stream. */ JPG_RET_INVALID_HANDLE, /**< This means that the given handle for the current API function call was invalid(for example, not initialized yet, improper function call for the given handle, etc.). */ JPG_RET_INVALID_PARAM, /**< This means that the given argument parameters (for example, input data structure) was invalid (not initialized yet or not valid anymore). */ JPG_RET_INVALID_COMMAND, /**< This means that the given command was invalid (for example, undefined, or not allowed in the given instances). */ JPG_RET_ROTATOR_OUTPUT_NOT_SET, /**< This means that rotator output buffer was not allocated even though postprocessor (rotation, mirroring, or deringing) is enabled. */ JPG_RET_ROTATOR_STRIDE_NOT_SET, /**< This means that rotator stride was not provided even though postprocessor (rotation, mirroring, or deringing) is enabled. */ JPG_RET_FRAME_NOT_COMPLETE, /**< This means that frame decoding operation was not completed yet, so the given API function call cannot be allowed. */ JPG_RET_INVALID_FRAME_BUFFER, /**< This means that the given source frame buffer pointers were invalid in encoder (not initialized yet or not valid anymore). */ JPG_RET_INSUFFICIENT_FRAME_BUFFERS, /**< This means that the given numbers of frame buffers were not enough for the operations of the given handle. */ JPG_RET_INVALID_STRIDE, /**< This means that the given stride was invalid (for example, 0, not a multiple of 8 or smaller than picture size). */ JPG_RET_WRONG_CALL_SEQUENCE, /**< This means that the current API function call was invalid considering the allowed sequences between API functions (for example, missing one crucial function call before this function call). */ JPG_RET_CALLED_BEFORE, /**< This means that multiple calls of the current API function for a given instance are invalid. */ JPG_RET_NOT_INITIALIZED, /**< This means that JPU was not initialized yet. Before calling any API functions, the initialization API function, JPU_Init(), should be called at the beginning. */ JPG_RET_INSUFFICIENT_RESOURCE, /**< This means that JPU cannot allocate memory due to lack of memory. */ JPG_RET_INST_CTRL_ERROR, /**< This means there was a fault in instance control. */ JPG_RET_NOT_SUPPORT, /**< This means that HOST application uses an API option that is not supported in current hardware. */ } JpgRet; /** * @brief This is a special enumeration type for representing the current encoder states. */ typedef enum { ENCODE_STATE_NEW_FRAME = 0, /**< The state indicates the start of a new frame. It appears for slice encoding. */ ENCODE_STATE_FRAME_DONE = 0, /**< The state indicates the completion of encoding a frame. */ ENCODE_STATE_SLICE_DONE = 1 /**< The state indicates the completion of encoding a slice. */ } EncodeState; /** * @brief This is an enumeration type for representing mirroring directions. */ typedef enum { MIRDIR_NONE, /**< No mirroring */ MIRDIR_VER, /**< Vertical mirroring */ MIRDIR_HOR, /**< Horizontal mirroring */ MIRDIR_HOR_VER /**< Horizontal and veritical mirroring */ } JpgMirrorDirection; /** * @brief This is an enumeration type for representing frame buffer formats. */ typedef enum { FORMAT_420 = 0, /**< YUV420 format */ FORMAT_422 = 1, /**< YUV422 format */ FORMAT_440 = 2, /**< YUV440 format */ FORMAT_444 = 3, /**< YUV444 format */ FORMAT_400 = 4, /**< YUV400 format */ FORMAT_MAX } FrameFormat; /** * @brief This is an enumeration type for representing a CbCr interleave mode of frame buffer. */ typedef enum { CBCR_SEPARATED = 0, /**< Cb data and Cr data are located in each separate plane. */ CBCR_INTERLEAVE, /**< Chroma data are interleaved in Cb and Cr order. */ CRCB_INTERLEAVE /**< Chroma data are interleaved in Cr and Cb order. */ } CbCrInterLeave; /** * @brief This is an enumeration type for representing a packed format of frame buffer. */ typedef enum { PACKED_FORMAT_NONE, PACKED_FORMAT_422_YUYV, /**< This is YUV422 packed format with YUYV component order. */ PACKED_FORMAT_422_UYVY, /**< This is YUV422 packed format with UYVY component order. */ PACKED_FORMAT_422_YVYU, /**< This is YUV422 packed format with YVYU component order. */ PACKED_FORMAT_422_VYUY, /**< This is YUV422 packed format with VYUY component order. */ PACKED_FORMAT_444, /**< This is YUV444 packed format. */ PACKED_FORMAT_MAX } PackedFormat; typedef enum { O_FMT_NONE, O_FMT_420, O_FMT_422, O_FMT_444, O_FMT_MAX } OutputFormat; /* Assume that pixel endianness is big-endian. * b0 is low address in a framebuffer. * b1 is high address in a framebuffer. * pixel consists of b0 and b1. * RIGHT JUSTIFICATION: (default) * lsb msb * |----|--------| * |0000| pixel | * |----|--------| * | b0 | b1 | * |-------------| * LEFT JUSTIFICATION: * lsb msb * |--------|----| * | pixel |0000| * |--------|----| * | b0 | b1 | * |-------------| */ enum JPU_PIXEL_JUSTIFICATION { PIXEL_16BIT_MSB_JUSTIFIED, PIXEL_16BIT_LSB_JUSTIFIED, PIXEL_16BIT_JUSTIFICATION_MAX, }; /** * @brief This is an enumeration type for representing the JPU interrupt reasons. */ typedef enum { INT_JPU_DONE = 0, /**< This interrupt indicates the completion of encoding/decoding a frame. */ INT_JPU_ERROR = 1, /**< This interrupt indicates occurrence of error. */ INT_JPU_BIT_BUF_EMPTY = 2, /**< This interrupt indicates JPU encounters empty bitstream buffer while decoding. */ INT_JPU_BIT_BUF_FULL = 2, /**< This interrupt indicates full state of bitstream buffer while encoding. */ /* For encoder */ INT_JPU_SLICE_DONE = 9, /**< This interrupt indicates the completion of encoding a slice. */ /* For encoder */ }InterruptJpu; /** * @brief This is an enumeration type for representing quantization and Huffman table encoding modes. */ typedef enum { JPG_TBL_NORMAL, } JpgTableMode; /** * @brief This is an enumeration type for representing encode header modes. */ typedef enum { ENC_HEADER_MODE_NORMAL, /**< Generation of the whole JPEG header syntaxes */ ENC_HEADER_MODE_SOS_ONLY /**< Generation of scan header syntax only */ } JpgEncHeaderMode; /** * @brief This is an enumeration type for representing scale down ratios. */ enum JPU_DOWNSCALE_VAL { JPG_SCALE_DOWN_NONE, /**< No scaling */ JPG_SCALE_DOWN_ONE_HALF, /**< 1/2 scale*/ JPG_SCALE_DOWN_ONE_QUARTER, /**< 1/4 scale */ JPG_SCALE_DOWN_ONE_EIGHTS, /**< 1/8 scale */ JPG_SCALE_DOWN_MAX }; /** * @brief This is an enumeration type for representing a product ID. */ enum JPU_PRODUCT_ID { PRODUCT_ID_CODAJ12 = 12, }; /** * @brief @verbatim This is a data structure for representing frame buffer pointers of each Y/Cb/Cr color component. In case of CbCr interleave mode, Cb and Cr frame data are written to memory area starting from the given bufCb address. All of the Y/Cb/Cr component addresses must be 8-byte aligned. A pixel value occupies 1 byte for JPEG baseline sequential and 2 bytes for JPEG extended sequential(12bit). In case the frame format is YCbCr420, the sizes of Cb and Cr buffer are 1/4 of Y buffer size. Host application must allocate frame buffers for each Y/Cb/Cr component in consideration of alignment and chroma format buffer size . @endverbatim */ typedef struct { PhysicalAddress bufY; /**< It indicates the base address for Y component in the physical address space when linear map is used. */ PhysicalAddress bufCb; /**< It indicates the base address for Cb component in the physical address space when linear map is used. */ PhysicalAddress bufCr; /**< It indicates the base address for Cr component in the physical address space when linear map is used. */ Uint32 stride; /**< A horizontal stride for luma frame buffer */ /* luma stride */ Uint32 strideC;/**< A horizontal stride for chroma frame buffer */ /* chroma stride */ FrameFormat format; /**< <> */ /** @verbatim Bitstream buffer endianess @* 0 : little endian format @* 1 : big endian format @* 2 : 32 bits little endian format @* 3 : 32 bits big endian format @endverbatim */ Uint32 endian; } FrameBuffer; struct JpgInst; /** * @brief This is a dedicated type for JPG handle returned when an instance is opened. An instance can be referred to by the corresponding handle. Application does not need to care about it. */ typedef struct JpgInst * JpgHandle; //------------------------------------------------------------------------------ // decode struct and definition //------------------------------------------------------------------------------ typedef struct JpgInst JpgDecInst; /** * @brief @verbatim This is a dedicated type for decoder handle returned when a decoder instance is opened. A decoder instance can be referred to by the corresponding handle. JpgDecInst is a type managed internally by API. Application does not need to care about it. NOTE: This type is vaild for decoder only. @endverbatim */ typedef JpgDecInst * JpgDecHandle; /* JPU Capabilities */ /** * @brief This is a data structure for representing JPU capabilities. */ typedef struct { Uint32 productId; /**< Product ID number, 12 */ Uint32 revisoin; /**< Revision number of hardware */ BOOL support12bit; /**< It indicates whether to support an extended sequential JPEG, 12bit. */ } JPUCap; /** * @brief This data structure is used when host application wants to open a new decoder instance. */ typedef struct { PhysicalAddress bitstreamBuffer; /**< The start address of bit stream buffer from which the decoder can get the next bitstream. This address must be 8-byte aligned.*/ Uint32 bitstreamBufferSize; /**< The virtual address according to bitstreamBuffer. This address is needed when the host wants to access bitstream.*/ BYTE* pBitStream; /**< The size of the buffer pointed by bitstreamBuffer in byte. This value must be a multiple of 1024. The maximum size is 16383 x 1024 bytes.*/ /** @verbatim Bitstream buffer endianess @* 0 : little endian format @* 1 : big endian format @* 2 : 32 bits little endian format @* 3 : 32 bits big endian format @endverbatim */ Uint32 streamEndian; /** @verbatim Frame buffer endianess * 0 : little endian format * 1 : big endian format * 2 : 32 bits little endian format * 3 : 32 bits big endian format @endverbatim */ Uint32 frameEndian; /** @verbatim @* 0: CbCr data is written in separate frame memories (chroma separate mode) @* 1: CbCr data is interleaved in chroma memory. (chroma interleave mode) @endverbatim */ CbCrInterLeave chromaInterleave; PackedFormat packedFormat; /**< This is for packed image format. It is valid only when source image format is written in YUV444 or RGB24. */ BOOL roiEnable; /**< This enables the ROI (Region of Interest). */ Uint32 roiOffsetX; /**< This is ROI offset for width. */ Uint32 roiOffsetY; /**< This is ROI offset for height. */ Uint32 roiWidth; /**< This is ROI width from RoiOffsetX. */ Uint32 roiHeight; /**< This is ROI width from RoiOffsetY. */ Uint32 pixelJustification; /**< It specifies pixel justification of source image for 12bit encoding mode. */ /* avaliable in 16bit pixel. */ Uint32 intrEnableBit; /**< It specifies an interrupt enable bit. For the meaning of each bit, refer to <>. */ Uint32 rotation; /**< It rotates decoded images in 0, 90, 180, or 270 degree */ JpgMirrorDirection mirror; /**< <> */ FrameFormat outputFormat; /**< <> */ } JpgDecOpenParam; /** * @brief Data structure to get information necessary to start decoding from the decoder. */ typedef struct { /** @verbatim Horizontal picture size in pixels This width value will be used while allocating decoder frame buffers. In some cases, this returned value, the display picture width declared on stream header, should be modified before allocating frame buffers. When picture width is not a multiple of 16, picture width for buffer allocation should be re-calculated from the declared display width as follows: picBufWidth = {( picWidth + 15)/16}* 16, where picBufWidth is the horizontal picture buffer width. When picWidth is a multiple of 16, picWidth = picBufWidth. */ int picWidth; /** @verbatim Vertical picture size in pixels This height value will be used while allocating decoder frame buffers. In some cases, this returned value, the display picture height declared on stream header, should be modified before allocating frame buffers. When picture height is not a multiple of 16, picture height for buffer allocation should be re-calculated from the declared display height as follows: picBufHeight = {( picHeight + 15)/16}* 16, where picBufHeight is the vertical picture buffer height. When picHeight is a multiple of 16, picHeight = picBufHeight. @endverbatim */ int picHeight; /** This is the minimum number of frame buffers required for decoding. Applications must allocate at least as many as this number of frame buffers and register the number of buffers to the JPU using JPU_DecRegisterFrameBuffer() before decoding pictures. */ int minFrameBufferCount; FrameFormat sourceFormat; /**< <> */ int ecsPtr; /**< This is an entropy-coded segment pointer of the first frame. */ int roiFrameWidth; /**< This is width of ROI region. */ int roiFrameHeight;/**< This is height of ROI region. */ int roiFrameOffsetX; /**< This is x position of ROI region. */ int roiFrameOffsetY; /**< This is y position of ROI region. */ Uint32 bitDepth; /**< 8 for baseline sequential, 12 for extended sequential */ } JpgDecInitialInfo; /** * @brief The data structure to set a scaler ratio. */ typedef struct { int scaleDownRatioWidth; /**< The ratio of frame width to scale down */ /** @verbatim The ratio of frame height to scale down. It might have one of the following values: @* 0 : no scale @* 1 : (1/2 scale) @* 2 : (1/4 scale) @* 3 : (1/8 scale) @endverbatim */ int scaleDownRatioHeight; } JpgDecParam; /** * @brief The data structure to get result information from decoding a frame. */ typedef struct { /** This is the frame buffer index of a picture to be displayed this time among frame buffers which were registered using JPU_DecRegisterFrameBuffer(). Frame data to be displayed this time will be stored into the frame buffer specified by this index. When delay in display does not exist, this index will always be the same with indexFrameDecoded. At the end of sequence decoding, if there is no more output for display, then this value will have -1 (0xFFFF). So by checking this index, host applications can easily know whether sequence decoding has been finished or not. */ int indexFrameDisplay; int numOfErrMBs; /**< The number of erroneous macroblocks while decoding a picture */ /** @verbatim @* 0 : incomplete finish of decoding process @* 1 : complete finish of decoding process @endverbatim */ int decodingSuccess; int decPicHeight; /**< The JPU reports the height of a decoded picture in pixel unit after decoding one frame. This value will be updated, when sequence information for resolution is changed. */ int decPicWidth; /**< The JPU reports the width of a decoded picture in pixel unit after decoding one frame. This value will be updated, when sequence information for resolution is changed. */ int consumedByte; /**< This means how many bytes are consumed in a bitstream. */ int bytePosFrameStart; /**< This means the position of an SOI maker in bitstream buffer. */ int ecsPtr; /**< This is a pointer to an entropy-coded segment of current frame. */ Uint32 frameCycle; /**< This variable reports the number of clock cycles taken to decode one frame. */ /* clock cycle */ Uint32 rdPtr; /**< The position of read pointer in the bitstream buffer after completion of frame decoding */ Uint32 wrPtr; /**< The position of write pointer in the bitstream buffer after completion of frame decoding */ } JpgDecOutputInfo; //------------------------------------------------------------------------------ // encode struct and definition //------------------------------------------------------------------------------ typedef struct JpgInst JpgEncInst; /** * @brief @verbatim This is a dedicated type for encoder handle returned when an encoder instance is opened. An encoder instance can be referred to by the corresponding handle. JpgEncInst is a type managed internally by API. Application does not need to care about it. NOTE: This type is vaild for encoder only. @endverbatim */ typedef JpgEncInst * JpgEncHandle; /** * @brief This data structure is used when host applications want to open a new encoder instance. */ typedef struct { PhysicalAddress bitstreamBuffer; /**< The start address of bit stream buffer into which encoder puts bit streams. This address must be a multiple of 4, namely, 4 byte-aligned. */ Uint32 bitstreamBufferSize; /**< The size of the buffer in bytes pointed by bitstreamBuffer. This value must be a multiple of 1024. The maximum size is 16383 x 1024 bytes. */ Uint32 picWidth; /**< The width of a picture to be encoded in pixels */ Uint32 picHeight; /**< The height of a picture to be encoded in pixels */ FrameFormat sourceFormat; /**< <> */ Uint32 restartInterval; /**< The number of MCU in the restart interval */ /** @verbatim Bitstream buffer endianess @* 0 : little endian format @* 1 : big endian format @* 2 : 32 bits little endian format @* 3 : 32 bits big endian format @endverbatim */ Uint32 streamEndian; /** @verbatim Frame buffer endianess @* 0 : little endian format @* 1 : big endian format @* 2 : 32 bits little endian format @* 3 : 32 bits big endian format @endverbatim */ Uint32 frameEndian; /** @verbatim @* 0 : CbCr data is written in separate frame memories (chroma separate mode) @* 1 : CbCr data is interleaved in chroma memory. (chroma interleave mode) @endverbatim */ CbCrInterLeave chromaInterleave; BYTE huffVal[8][256]; /**< A list of the 8-bit symbol values in Huffman tables. */ BYTE huffBits[8][256]; /**< A 16-byte list giving number of codes for each code length from 1 to 16 in Huffman tables. */ short qMatTab[4][64]; /**< Quantization tables */ BOOL jpg12bit; /**< It enables 12bit encoding mode. */ BOOL q_prec0; /**< Luma quantization tables for 12bit encoding mode */ BOOL q_prec1; /**< Chroma quantization tables for 12bit encoding mode */ PackedFormat packedFormat; /**< It specifies a packed image format. It is valid only when source image format is written in YUV444 or RGB24. */ Uint32 pixelJustification; /**< It specifies pixel justification of source image for 12bit encoding mode. */ Uint32 tiledModeEnable; /**< It enables use of tiled mode. */ Uint32 sliceHeight; /**< It specifies a slice height for slice encoding. */ Uint32 intrEnableBit; /**< It specifies an interrupt enable bit. For the meaning of each bit, refer to <>. */ BOOL sliceInstMode; Uint32 rotation; /**< It rotates source images in 0, 90, 180, or 270 degree before encoding. */ Uint32 mirror; /**< <> */ } JpgEncOpenParam; /** * @brief This is a data structure for configuring one frame encoding operation. */ typedef struct { FrameBuffer * sourceFrame; /**< This member must represent the frame buffer containing source image to be encoded. */ } JpgEncParam; /** * @brief This is a data structure for reporting the results of picture encoding operations. */ typedef struct { /** The Physical address of the starting point of newly encoded picture stream If dynamic buffer allocation is enabled in line-buffer mode, this value will be identical with the specified picture stream buffer address by host applications. */ PhysicalAddress bitstreamBuffer; Uint32 bitstreamSize; /**< The byte size of encoded bitstream */ PhysicalAddress streamRdPtr; /**< A read pointer of bitstream buffer */ PhysicalAddress streamWrPtr; /**< A write pointer of bitstream buffer */ Uint32 encodedSliceYPos; /**< A vertical position of the currently encoded slice */ EncodeState encodeState; /**< A result of the current encoding, completion of encoding the whole picture or completion of encoding a specific slice */ Uint32 frameCycle; /**< This variable reports the number of clock cycles taken to decode one frame. */ /* clock cycle */ } JpgEncOutputInfo; /** * @brief This is a data structure for generating an encoding header. */ typedef struct { PhysicalAddress paraSet; /**< The physical address of bitstream buffer where header bitstream is saved */ BYTE *pParaSet; /**< The virtual address of bitstream buffer where header bitstream is saved */ int size; /**< The allocation size of buffer for saving header bitstream */ /** @verbatim Header encoding mode @* ENC_HEADER_MODE_NORMAL: generates all sorts of headers. @* ENC_HEADER_MODE_SOS_ONLY: generates only SOS header (not any other such as SOI, APP, DRI, DQT, DHT, and SOF headers). @endverbatim */ int headerMode; /** @verbatim Quantization table merge option @* 0: do not merge quantization table @* 1: merge quantization table @endverbatim */ int quantMode; /** @verbatim Huffman table merge option @* 0: do not merge huffman table @* 1: merge huffman table @endverbatim */ int huffMode; int disableAPPMarker; /**< It disables generating an App Marker in encoding header. */ int enableSofStuffing; /**< It enables to fill 0xff at the end of header if it is not 8-byte aligned after encoding the header. (defalut: 0x00) */ } JpgEncParamSet; #ifdef __cplusplus extern "C" { #endif /** * @brief This function returns whether the JPU is initialized and ready to be used. * @return @verbatim @* 0: The JPU hardware is not initialized yet. In that case, host application should call JPU_Init(). @* 1: The JPU hardware is initialized. @endverbatim */ Uint32 JPU_IsInit( void ); /** * @brief This function waits until an interrupt arises and returns the interrupt reason if it occurs. * @param handle [Input] An instance handle obtained from JPU_EncOpen() or JPU_DecOpen() * @param timeout [Input] A timeout value in millisecond * @return @verbatim @* 0: The JPU hardware is not initialized yet. In that case, host application should call JPU_Init(). @* 1: The JPU hardware is initialized. @endverbatim */ Int32 JPU_WaitInterrupt(JpgHandle handle, int timeout); /** * @brief This function returns whether JPU has completed processing a frame or not. * @param handle [Input] An instance handle obtained from JPU_EncOpen() or JPU_DecOpen() * @return @verbatim @* 0: The JPU hardware is idle. @* Non-zero value: The JPU hardware is busy with processing a frame. @endverbatim */ int JPU_IsBusy(JpgHandle handle); /** * @brief This function returns the reason of JPU interrupt. * @param handle [Input] An instance handle obtained from JPU_EncOpen() or JPU_DecOpen() * @return @verbatim @* 0: No Interrupt, The JPU hardware is idle. @* Non-zero value: It is an interrupt reason. Refer to <> to know the meaning of each bit. @endverbatim */ Uint32 JPU_GetStatus(JpgHandle handle); /** * @brief Clearing Interrupt * @param handle [Input] An instance handle obtained from JPU_EncOpen() * @param val [Input] The interrupt bit to be cleared * @return None */ void JPU_ClrStatus(JpgHandle handle, Uint32 val); /** * @brief This function initializes the JPU hardware and proper data structures/resources. Applications must call this function only once before using the JPU. * @param None * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means the JPU initialized successfully. *JPG_RET_FAILURE*:: Operation was failed, which means the JPU initialized with fail. @endverbatim */ JpgRet JPU_Init(); /** * @brief This function frees all the resources allocated by API. * @param None * @return None */ void JPU_DeInit(); /** * @brief This function returns the number of instances that have opened. * @param None * @return The number of instance that is currently running */ int JPU_GetOpenInstanceNum(); /** * @brief Applications can read out the version information running on the system. * @param apiVersion [output] API version ID * @param hwRevision [output] Hardware versi * @param hwProductId [output] Product ID * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means version information is acquired successfully. *JPG_RET_NOT_INITIALIZED*:: JPU was not initialized at all before calling this function. Application should initialize JPU by calling JPU_Init() before calling this function. @endverbatim */ JpgRet JPU_GetVersionInfo( Uint32 *apiVersion, Uint32 *hwRevision, Uint32 *hwProductId); /** * @brief This function resets JPU and initializes all the internal contexts. It can be done by user's system reset signal and implmentation of jdi_hw_reset(). * @param None * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means the JPU has been reset successfully. *JPG_RET_FAILURE*:: Operation was failed, which means the JPU was unable to reset. @endverbatim */ JpgRet JPU_HWReset(); /** * @brief This function resets JPU by using the reset register. * @param None * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means the JPU has been reset successfully. @endverbatim */ JpgRet JPU_SWReset(); // function for decode /** * @brief In order to decode, applications must open the decoder. By calling this function, applications can get a handle by which they can refer to a decoder instance. Because the JPU is multiple instance codec, applications need this kind of handle. Once an application gets a handle, the application must pass this handle to all subsequent decoder-related functions. * @param handle [Output] A pointer to a JpgDecHandle type variable which will specify each instance for application. * @param openParam [Input] A pointer to a JpgDecOpenParam type structure which describes required parameters for creating a new decoder instance. * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means a new decoder instance was created successfully. *JPG_RET_FAILURE*:: Operation was failed, which means getting a new decoder instance was not done successfully. If there is no free instance anymore, this value will be returned in this function call. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). @endverbatim */ JpgRet JPU_DecOpen( JpgDecHandle* handle, JpgDecOpenParam* openParam); /** * @brief When an application finished decoding a sequence and wanted to release this instance for other processing, the applicaton should close this instance. After completion of this function call, the instance referred to by handle will get free. Once an application closes an instance, the application cannot call any further decoder-specific function with the current handle before re-opening a new decoder instance with the same handle. * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means current decoder instance was closed successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). @endverbatim */ JpgRet JPU_DecClose( JpgDecHandle handle); /** * @brief @verbatim Applications must pass the address of a JpgDecInitialInfo structure, where the decoder will store information such as picture size, number of necessary frame buffers, etc. For the details, see definition of the section called JpgDecInitialInfo data structure. This function should be called once after creating a decoder instance and before starting frame decoding. It is application\'s responsibility to provide sufficient amount of bitstream to the decoder by calling JPU_DecUpdateBitstreamBuffer() so that bitstream buffer does not get empty before this function returns. @endverbatim * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param info [Output] A pointer to JpgDecInitialInfo data structure * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means required information of the stream data to be decoded was received successfully. *JPG_RET_FAILURE*:: Operation was failed, which means there was an error in getting information for configuring the decoder. *JPG_RET_INVALID_PARAM*:: The given argument parameter, info, was invalid, which means it has a null pointer, or given values for some member variables are improper values. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). @endverbatim */ JpgRet JPU_DecGetInitialInfo( JpgDecHandle handle, JpgDecInitialInfo * info); /** * @brief @verbatim This function is used for registering frame buffers with the acquired information from JPU_DecGetInitialInfo(). The frame buffers pointed to by bufArray will be managed internally within the JPU. These include reference frames, reconstructed frame, etc. Applications must not change the contents of the array of frame buffers during the life time of the instance, and num must not be less than minFrameBufferCount obtained by JPU_DecGetInitialInfo(). The distance between a pixel in a row and the corresponding pixel in the next row is called a stride. The value of stride must be a multiple of 8. The address of the first pixel in the second row does not necessarily coincide with the value next to the last pixel in the first row. In other words, a stride can be greater than the picture width in pixels. Applications should not set a stride value smaller than the picture width. So, for Y component, application must allocate at least a space of size (frame height stride), and Cb or Cr component, (frame height/2 stride/2), respectively. But make sure that in Cb/Cr non-interleave (separate Cb/Cr) map, the stride for luminance frame buffers should be multiple of 16 so that the stride for chrominance frame buffers can become a multiple of 8. In case of MJPEG encoding, the address of frame buffer is not necessary and only stride value is required, which will be used as source image stride. @endverbatim * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param bufArray [Input] A number of the minimum frame buffer count * @param num [Input] A number of frame buffers * @param stride [Input] A stride value of the given frame buffers * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means registering frame buffer information was done successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_WRONG_CALL_SEQUENCE*:: This means current API function call was invalid considering the allowed sequences between API functions. An application might call this function before calling JPU_DecGetInitialInfo() successfully. This function should be called after successful calling JPU_DecGetInitialInfo(). *JPG_RET_INVALID_FRAME_BUFFER*:: This happens when bufArray was invalid, which means bufArray was not initialized yet or not valid anymore. *JPG_RET_INSUFFICIENT_FRAME_BUFFERS*:: This means the given number of frame buffers, num, was not enough for the decoder operations of the given handle. It should be greater than or equal to the value requested by JPU_DecGetInitialInfo(). *JPG_RET_INVALID_STRIDE*:: The given argument stride was invalid, which means it is smaller than the decoded picture width, or is not a multiple of 8 in this case. @endverbatim */ JpgRet JPU_DecRegisterFrameBuffer( JpgDecHandle handle, FrameBuffer * bufArray, int num, int stride); /** * @brief @verbatim This function is used for registering frame buffers with the acquired information from JPU_DecGetInitialInfo(). The frame buffers pointed to by bufArray will be managed internally within the JPU. These include reference frames, reconstructed frame, etc. Applications must not change the contents of the array of frame buffers during the life time of the instance, and num must not be less than minFrameBufferCount obtained by JPU_DecGetInitialInfo(). The distance between a pixel in a row and the corresponding pixel in the next row is called a stride. The value of stride must be a multiple of 8. The address of the first pixel in the second row does not necessarily coincide with the value next to the last pixel in the first row. In other words, a stride can be greater than the picture width in pixels. Applications should not set a stride value smaller than the picture width. So, for Y component, application must allocate at least a space of size (frame height stride), and Cb or Cr component, (frame height/2 stride/2), respectively. But make sure that in Cb/Cr non-interleave (separate Cb/Cr) map, the stride for luminance frame buffers should be multiple of 16 so that the stride for chrominance frame buffers can become a multiple of 8. In case of MJPEG encoding, the address of frame buffer is not necessary and only stride value is required, which will be used as source image stride. @endverbatim * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param prdPrt [Input] A stream buffer read pointer for the current decoder instance * @param pwrPtr [Input] A stream buffer write pointer for the current decoder instance * @param size [Input] A variable specifying the available space in bitstream buffer for the current decoder instance * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means registering frame buffer information was done successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_WRONG_CALL_SEQUENCE*:: This means current API function call was invalid considering the allowed sequences between API functions. An application might call this function before calling JPU_DecGetInitialInfo() successfully. This function should be called after successful calling JPU_DecGetInitialInfo(). *JPG_RET_INVALID_FRAME_BUFFER*:: This happens when bufArray was invalid, which means bufArray was not initialized yet or not valid anymore. *JPG_RET_INSUFFICIENT_FRAME_BUFFERS*:: This means the given number of frame buffers, num, was not enough for the decoder operations of the given handle. It should be greater than or equal to the value requested by JPU_DecGetInitialInfo(). *JPG_RET_INVALID_STRIDE*:: The given argument stride was invalid, which means it is smaller than the decoded picture width, or is not a multiple of 8 in this case. @endverbatim */ JpgRet JPU_DecGetBitstreamBuffer( JpgDecHandle handle, PhysicalAddress * prdPrt, PhysicalAddress * pwrPtr, int * size ); /** * @brief Applications must let decoder know how much bitstream has been transferred to the address obtained from JPU_DecGetBitstreamBuffer(). By just giving the size as an argument, API automatically handles pointer wrap-around and updates the write pointer. * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param size [Input] A variable specifying the amount of bits transferred into bitstream buffer for the current decoder instance * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means putting new stream data was done successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). @endverbatim */ JpgRet JPU_DecUpdateBitstreamBuffer( JpgDecHandle handle, int size); /** * @brief This function starts decoding one frame. Returning from this function does not mean the completion of decoding one frame, and it is just that decoding one frame was initiated. Every call of this function should be matched with JPU_DecGetOutputInfo() with the same handle. Without calling a pair of these funtions, applications cannot call any other API functions except for JPU_IsBusy(), JPU_DecGetBitstreamBuffer(), and JPU_DecUpdateBitstreamBuffer(). * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param param [Input] A pointer to a JpgDecParam type structure which describes picture decoding parameters for the given decoder instance * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means decoding a new frame was started successfully. NOTE: This return value does not mean that decoding a frame was completed successfully. *JPG_RET_FAIURE*:: Operation was failed, which means there was an error in starting a frame. *JPG_RET_INVALID_PARAM*:: This happens when param was invalid, which means param was not initialized yet or not valid anymore. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_FRAME_NOT_COMPLETE*:: This means frame decoding operation was not completed yet, so the given API function call cannot be performed this time. A frame decoding operation should be completed by calling JPU_DecGetOutputInfo(). Even though the result of the current frame operation is not necessary, application should call JPU_DecGetOutputInfo() to proceed this function call. *JPG_RET_WRONG_CALL_SEQUENCE*:: This means current API function call was invalid considering the allowed sequences between API functions. An application might call this function before successfully calling JPU_DecRegisterFrameBuffer(). This function should be called after calling JPU_ DecRegisterFrameBuffer() successfully. *JPG_RET_BIT_EMPTY*:: This means the bit-stream buffer is empty. So, API requests the bit-stream data. *JPG_RET_EOS*:: This means the stream ends. @endverbatim */ JpgRet JPU_DecStartOneFrame( JpgDecHandle handle, JpgDecParam *param ); JpgRet JPU_DecStartOneFrameBySerialNum( JpgDecHandle handle, JpgDecParam *param, int bufferIndex ); /** * @brief Application can get the information of output of decoding. The information includes the information of a frame buffer which contains the reconstructed image. Host applications should call this function after frame decoding is finished and before starting the further processing. * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param info [Output] A pointer to a JpgDecOutputInfo type structure which describes picture decoding results for the current decoder instance. * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means receiving the output information of current frame was done successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_WRONG_CALL_SEQUENCE*:: This means current API function call was invalid considering the allowed sequences between API functions. It might happen because JPU_DecStartOneFrame() with the same handle was not called before calling this function. *JPG_RET_INVALID_PARAM*:: The given argument parameter, info, was invalid, which means it has a null pointer, or given values for some member variables are improper values. @endverbatim */ JpgRet JPU_DecGetOutputInfo( JpgDecHandle handle, JpgDecOutputInfo * info); /** * @brief @verbatim This function is provided to let application have a certain level of freedom for re-configuring decoder operation after creating a decoder instance. Some options which can be changed dynamically during decoding as the video sequence has been included. Some command-specific return codes are also presented. The list of valid commands can be summarized as follows: @* SET_JPG_SCALE_HOR @* SET_JPG_SCALE_VER @* ENABLE_LOGGING @* DISABLE_LOGGING @endverbatim * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param cmd [Intput] A variable specifying the given command of <> * @param parameter [Input/Output] A pointer to command-specific data structure which describes picture I/O parameters for the current decoder instance * @return @verbatim *JPG_RET_INVALID_COMMAND*:: The given argument, cmd, was invalid, which means the given cmd was undefined, or not allowed in the current instance. *JPG_RET_SUCCESS*:: Operation was done successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). @endverbatim */ JpgRet JPU_DecGiveCommand( JpgDecHandle handle, JpgCommand cmd, void * parameter); /** * @brief This function specifies the location of read pointer in bitstream buffer. It can also set a write pointer with same value of read pointer (addr) when updateWrPtr is not a zero value, which allows to flush up the bitstream buffer at once. * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param addr [Input] Updated read or write pointer * @param updateWrPtr [Input] A flag whether to update a write pointer or not as well as a read pointer. * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means required information of the stream data to be decoded was received successfully. *JPG_RET_FAIURE*:: Operation was failed, which means there was an error in starting a frame. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_FRAME_NOT_COMPLETE*:: This means frame decoding operation was not completed yet, so the given API function call cannot be performed this time. A frame decoding operation should be completed by calling JPU_DecSetRdPtr(). @endverbatim */ JpgRet JPU_DecSetRdPtr( JpgDecHandle handle, PhysicalAddress addr, BOOL updateWrPtr); /** * @brief This function is used to change the location of read pointer in bitstream buffer. It is useful when host application decodes MJPEG with binary of every frame which is obtained from demuxer. After frame decoding, host application can use this function which allows the given read pointer to be the base address of bitstream buffer like in line buffer mode. * @param handle [Input] A decoder handle obtained from JPU_DecOpen() * @param addr [Input] Updated read or write pointer * @param updateWrPtr [Input] A flag whether to update a write pointer or not as well as a read pointer. * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means required information of the stream data to be decoded was received successfully. *JPG_RET_FAIURE*:: Operation was failed, which means there was an error in starting a frame. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_FRAME_NOT_COMPLETE*:: This means frame decoding operation was not completed yet, so the given API function call cannot be performed this time. A frame decoding operation should be completed by calling JPU_DecSetRdPtr(). @endverbatim */ JpgRet JPU_DecSetRdPtrEx( JpgDecHandle handle, PhysicalAddress addr, BOOL updateWrPtr); // function for encode /** * @brief In order to start a new encoder operation, applications must open a new instance for this encoder operation. * @param handle [Output] A pointer to a JpgEncHandle type variable * @param openParam [Input] A pointer to a JpgEncOpenParam type structure * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means a new encoder instance was opened successfully. *JPG_RET_FAILURE*:: Operation was failed, which means getting a new encoder instance was not done successfully. If there is no free instance anymore, this value will be returned in this function call. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). @endverbatim */ JpgRet JPU_EncOpen( JpgEncHandle* handle, JpgEncOpenParam* openParam); /** * @brief When an application finished encoding operations and wanted to release this instance for other processing, the application should close this instance by calling this function. After completion of this function call, the instance referred to by handle will get free. Once an application closes an instance, the application cannot call any further encoder-specific function with the current handle before re-opening a new instance with the same handle. * @param handle [Input] An encoder handle obtained from JPU_EncOpen() * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully. That means current encoder instance was closed successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_FRAME_NOT_COMPLETE*:: This means frame decoding or encoding operation was not completed yet, so the given API function call cannot be performed this time. A frame encoding or decoding operation should be completed by calling JPU_EncGetOutputInfo() or JPU_DecGetOutputInfo(). Even though the result of the current frame operation is not necessary, applications should call JPU_EncGetOutputInfo() or JPU_DecGetOutputInfo() to proceed this function call. @endverbatim */ JpgRet JPU_EncClose( JpgEncHandle handle); /** * @brief After encoding frame, applications must get bitstream from the encoder. To do that, they must know where to get bitstream and the maximum size. Applications can get the information by calling this function. * @param handle [Input] A encoder handle obtained from JPU_EncOpen() * @param prdPrt [Output] A stream buffer read pointer for the current encoder instance * @param pwrPtr [Output] A stream buffer write pointer for the current encoder instance * @param size [Output] A variable specifying the available space in bitstream buffer for the current encoder instance * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means required information for encoder stream buffer was received successfully. *RETCODE_INVALID_PARAM*:: The given argument parameter, prdPrt, pwrPtr or size, was invalid, which means it has a null pointer, or given values for some member variables are improper values. @endverbatim */ JpgRet JPU_EncGetBitstreamBuffer( JpgEncHandle handle, PhysicalAddress * prdPrt, PhysicalAddress * pwrPtr, int * size); /** * @brief Applications must let encoder know how much bitstream has been transferred from the address obtained from JPU_EncGetBitstreamBuffer(). By just giving the size as an argument, API automatically handles pointer wrap-around and updates the read pointer. * @param handle [Input] A encoder handle obtained from JPU_EncOpen() * @param size [Input] A variable specifying the amount of bits being filled from bitstream buffer for the current encoder instance. If 0 is given, JPUAPI forces a read pointer and a write pointer to be wrapped around and to be updated. * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means putting new stream data was done successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). @endverbatim */ JpgRet JPU_EncUpdateBitstreamBuffer( JpgEncHandle handle, int size); /** * @brief @verbatim This function starts encoding one frame. Returning from this function does not mean the completion of encoding one frame, and it is just that encoding one frame was initiated. Every call of this function should be matched with JPU_EncGetOutputInfo() with the same handle. Without calling a pair of these funtions, applications cannot call any other API functions except for JPU_IsBusy(), JPU_EncGetBitstreamBuffer(), and JPU_EncUpdateBitstreamBuffer(). @endverbatim * @param handle [Input] An encoder handle obtained from JPU_EncOpen() * @param param [Input] A pointer to JpgEncParam type structure which describes picture encoding parameters for the current encoder instance. * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means encoding a new frame was started successfully. NOTE: This return value does not mean that encoding a frame was completed successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_FRAME_NOT_COMPLETE*:: This means frame decoding or encoding operation was not completed yet, so the given API function call cannot be performed this time. A frame encoding or decoding operation should be completed by calling JPU_EncGetOutputInfo() or JPU_DecGetOutputInfo(). Even though the result of the current frame operation is not necessary, applications should call JPU_EncGetOutputInfo() or JPU_DecGetOutputInfo() to proceed this function call. *JPG_RET_INVALID_PARAM*:: The given argument parameter, param, was invalid, which means it has a null pointer, or given values for some member variables are improper values. @endverbatim */ JpgRet JPU_EncStartOneFrame( JpgEncHandle handle, JpgEncParam * param ); /** * @brief This function gets information of the output of encoding. Application can know about picture type, the address and size of the generated bitstream, the number of generated slices, the end addresses of the slices, and macroblock bit position information. Host application should call this function after frame encoding is finished, and before starting the further processing. * @param handle [Input] An encoder handle obtained from JPU_EncOpen(). * @param info [Output] A pointer to a JpgEncOutputInfo type structure which describes picture encoding results for the current encoder instance. * @return @verbatim *JPG_RET_SUCCESS*:: Operation was done successfully, which means the output information of current frame encoding was received successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). *JPG_RET_WRONG_CALL_SEQUENCE*:: This means current API function call was invalid considering the allowed sequences between API functions. An application might call this function before calling JPU_EncStartOneFrame() successfully. This function should be called after successful calling of JPU_EncStartOneFrame(). *JPG_RET_INVALID_PARAM*:: The given argument parameter, info, was invalid, which means it has a null pointer, or given values for some member variables are improper values. @endverbatim */ JpgRet JPU_EncGetOutputInfo( JpgEncHandle handle, JpgEncOutputInfo * info); /** * @brief @verbatim This function is provided to let application have a certain level of freedom for re-configuring encoder operation after creating an encoder instance. Some options which can be changed dynamically during encoding as the video sequence has been included. Some command-specific return codes are also presented. The list of valid commands can be summarized as follows: @* SET_JPG_USE_STUFFING_BYTE_FF @* ENC_JPG_GET_HEADER @* ENABLE_LOGGING @* DISABLE_LOGGING @endverbatim * @param handle [Input] An encoder handle obtained from JPU_EncOpen() * @param cmd [Input] A variable specifying the given command of <> * @param param [Input/Output] A pointer to command-specific data structure which describes picture I/O parameters for the current encoder instance * @return @verbatim *JPG_RET_INVALID_COMMAND*:: This means the given argument, cmd, was invalid which means the given cmd was undefined, or not allowed in the current instance. *JPG_RET_INVALID_PARAM*:: The given argument parameter, info, was invalid, which means it has a null pointer, or given values for some member variables are improper values. *JPG_RET_SUCCESS*:: Operation was done successfully, which means the given cmd was received successfully. *JPG_RET_INVALID_HANDLE*:: This means the given handle for current API function call was invalid (for example, not initialized yet, improper function call for the given handle, etc.). @endverbatim */ JpgRet JPU_EncGiveCommand( JpgEncHandle handle, JpgCommand cmd, void * parameter); #ifdef __cplusplus } #endif #endif