|
STM32H735xx HAL User Manual
|
00001 /** 00002 ****************************************************************************** 00003 * @file stm32h7xx_hal_jpeg.h 00004 * @author MCD Application Team 00005 * @brief Header file of JPEG HAL module. 00006 ****************************************************************************** 00007 * @attention 00008 * 00009 * Copyright (c) 2017 STMicroelectronics. 00010 * All rights reserved. 00011 * 00012 * This software is licensed under terms that can be found in the LICENSE file 00013 * in the root directory of this software component. 00014 * If no LICENSE file comes with this software, it is provided AS-IS. 00015 * 00016 ****************************************************************************** 00017 */ 00018 00019 /* Define to prevent recursive inclusion -------------------------------------*/ 00020 #ifndef STM32H7xx_HAL_JPEG_H 00021 #define STM32H7xx_HAL_JPEG_H 00022 00023 #ifdef __cplusplus 00024 extern "C" { 00025 #endif 00026 00027 /* Includes ------------------------------------------------------------------*/ 00028 #include "stm32h7xx_hal_def.h" 00029 00030 #if defined (JPEG) 00031 00032 /** @addtogroup STM32H7xx_HAL_Driver 00033 * @{ 00034 */ 00035 00036 /** @addtogroup JPEG 00037 * @{ 00038 */ 00039 00040 /* Exported types ------------------------------------------------------------*/ 00041 /** @defgroup JPEG_Exported_Types JPEG Exported Types 00042 * @{ 00043 */ 00044 00045 /** @defgroup JPEG_Configuration_Structure_definition JPEG Configuration for encoding Structure definition 00046 * @brief JPEG encoding configuration Structure definition 00047 * @{ 00048 */ 00049 typedef struct 00050 { 00051 uint32_t ColorSpace; /*!< Image Color space : gray-scale, YCBCR, RGB or CMYK 00052 This parameter can be a value of @ref JPEG_ColorSpace */ 00053 00054 uint32_t ChromaSubsampling; /*!< Chroma Subsampling in case of YCBCR or CMYK color space, 0-> 4:4:4 , 1-> 4:2:2, 2 -> 4:1:1, 3 -> 4:2:0 00055 This parameter can be a value of @ref JPEG_ChromaSubsampling */ 00056 00057 uint32_t ImageHeight; /*!< Image height : number of lines */ 00058 00059 uint32_t ImageWidth; /*!< Image width : number of pixels per line */ 00060 00061 uint32_t ImageQuality; /*!< Quality of the JPEG encoding : from 1 to 100 */ 00062 00063 } JPEG_ConfTypeDef; 00064 /** 00065 * @} 00066 */ 00067 00068 /** @defgroup HAL_JPEG_state_structure_definition HAL JPEG state structure definition 00069 * @brief HAL JPEG State structure definition 00070 * @{ 00071 */ 00072 typedef enum 00073 { 00074 HAL_JPEG_STATE_RESET = 0x00U, /*!< JPEG not yet initialized or disabled */ 00075 HAL_JPEG_STATE_READY = 0x01U, /*!< JPEG initialized and ready for use */ 00076 HAL_JPEG_STATE_BUSY = 0x02U, /*!< JPEG internal processing is ongoing */ 00077 HAL_JPEG_STATE_BUSY_ENCODING = 0x03U, /*!< JPEG encoding processing is ongoing */ 00078 HAL_JPEG_STATE_BUSY_DECODING = 0x04U, /*!< JPEG decoding processing is ongoing */ 00079 HAL_JPEG_STATE_TIMEOUT = 0x05U, /*!< JPEG timeout state */ 00080 HAL_JPEG_STATE_ERROR = 0x06U /*!< JPEG error state */ 00081 } HAL_JPEG_STATETypeDef; 00082 00083 /** 00084 * @} 00085 */ 00086 00087 00088 /** @defgroup JPEG_handle_Structure_definition JPEG handle Structure definition 00089 * @brief JPEG handle Structure definition 00090 * @{ 00091 */ 00092 #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1) 00093 typedef struct __JPEG_HandleTypeDef 00094 #else 00095 typedef struct 00096 #endif /* (USE_HAL_JPEG_REGISTER_CALLBACKS) */ 00097 { 00098 JPEG_TypeDef *Instance; /*!< JPEG peripheral register base address */ 00099 00100 JPEG_ConfTypeDef Conf; /*!< Current JPEG encoding/decoding parameters */ 00101 00102 uint8_t *pJpegInBuffPtr; /*!< Pointer to JPEG processing (encoding, decoding,...) input buffer */ 00103 00104 uint8_t *pJpegOutBuffPtr; /*!< Pointer to JPEG processing (encoding, decoding,...) output buffer */ 00105 00106 __IO uint32_t JpegInCount; /*!< Internal Counter of input data */ 00107 00108 __IO uint32_t JpegOutCount; /*!< Internal Counter of output data */ 00109 00110 uint32_t InDataLength; /*!< Input Buffer Length in Bytes */ 00111 00112 uint32_t OutDataLength; /*!< Output Buffer Length in Bytes */ 00113 00114 MDMA_HandleTypeDef *hdmain; /*!< JPEG In MDMA handle parameters */ 00115 00116 MDMA_HandleTypeDef *hdmaout; /*!< JPEG Out MDMA handle parameters */ 00117 00118 uint8_t CustomQuanTable; /*!< If set to 1 specify that user customized quantization tables are used */ 00119 00120 uint8_t *QuantTable0; /*!< Basic Quantization Table for component 0 */ 00121 00122 uint8_t *QuantTable1; /*!< Basic Quantization Table for component 1 */ 00123 00124 uint8_t *QuantTable2; /*!< Basic Quantization Table for component 2 */ 00125 00126 uint8_t *QuantTable3; /*!< Basic Quantization Table for component 3 */ 00127 00128 HAL_LockTypeDef Lock; /*!< JPEG locking object */ 00129 00130 __IO HAL_JPEG_STATETypeDef State; /*!< JPEG peripheral state */ 00131 00132 __IO uint32_t ErrorCode; /*!< JPEG Error code */ 00133 00134 __IO uint32_t Context; /*!< JPEG Internal context */ 00135 00136 #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1) 00137 void (*InfoReadyCallback)(struct __JPEG_HandleTypeDef *hjpeg, 00138 JPEG_ConfTypeDef *pInfo); /*!< JPEG Info ready callback */ 00139 void (*EncodeCpltCallback)(struct __JPEG_HandleTypeDef 00140 *hjpeg); /*!< JPEG Encode complete callback */ 00141 void (*DecodeCpltCallback)(struct __JPEG_HandleTypeDef 00142 *hjpeg); /*!< JPEG Decode complete callback */ 00143 void (*ErrorCallback)(struct __JPEG_HandleTypeDef 00144 *hjpeg); /*!< JPEG Error callback */ 00145 void (*GetDataCallback)(struct __JPEG_HandleTypeDef *hjpeg, 00146 uint32_t NbDecodedData); /*!< JPEG Get Data callback */ 00147 void (*DataReadyCallback)(struct __JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, 00148 uint32_t OutDataLength); /*!< JPEG Data ready callback */ 00149 00150 void (* MspInitCallback)(struct __JPEG_HandleTypeDef *hjpeg); /*!< JPEG Msp Init callback */ 00151 void (* MspDeInitCallback)(struct __JPEG_HandleTypeDef 00152 *hjpeg); /*!< JPEG Msp DeInit callback */ 00153 00154 00155 #endif /* (USE_HAL_JPEG_REGISTER_CALLBACKS) */ 00156 00157 00158 } JPEG_HandleTypeDef; 00159 /** 00160 * @} 00161 */ 00162 00163 00164 #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1) 00165 /** @defgroup HAL_JPEG_Callback_ID_enumeration_definition HAL JPEG Callback ID enumeration definition 00166 * @brief HAL JPEG Callback ID enumeration definition 00167 * @{ 00168 */ 00169 typedef enum 00170 { 00171 HAL_JPEG_ENCODE_CPLT_CB_ID = 0x01U, /*!< JPEG Encode Complete callback ID */ 00172 HAL_JPEG_DECODE_CPLT_CB_ID = 0x02U, /*!< JPEG Decode Complete callback ID */ 00173 HAL_JPEG_ERROR_CB_ID = 0x03U, /*!< JPEG Error callback ID */ 00174 00175 HAL_JPEG_MSPINIT_CB_ID = 0x04U, /*!< JPEG MspInit callback ID */ 00176 HAL_JPEG_MSPDEINIT_CB_ID = 0x05U /*!< JPEG MspDeInit callback ID */ 00177 00178 } HAL_JPEG_CallbackIDTypeDef; 00179 /** 00180 * @} 00181 */ 00182 00183 /** @defgroup HAL_JPEG_Callback_pointer_definition HAL JPEG Callback pointer definition 00184 * @brief HAL JPEG Callback pointer definition 00185 * @{ 00186 */ 00187 typedef void (*pJPEG_CallbackTypeDef)(JPEG_HandleTypeDef *hjpeg); /*!< pointer to a common JPEG callback function */ 00188 typedef void (*pJPEG_InfoReadyCallbackTypeDef)(JPEG_HandleTypeDef *hjpeg, 00189 JPEG_ConfTypeDef *pInfo); /*!< pointer to an Info ready JPEG callback function */ 00190 typedef void (*pJPEG_GetDataCallbackTypeDef)(JPEG_HandleTypeDef *hjpeg, 00191 uint32_t NbDecodedData); /*!< pointer to a Get data JPEG callback function */ 00192 typedef void (*pJPEG_DataReadyCallbackTypeDef)(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, 00193 uint32_t OutDataLength); /*!< pointer to a Data ready JPEG callback function */ 00194 /** 00195 * @} 00196 */ 00197 00198 #endif /* USE_HAL_JPEG_REGISTER_CALLBACKS */ 00199 00200 /** 00201 * @} 00202 */ 00203 00204 /* Exported constants --------------------------------------------------------*/ 00205 00206 /** @defgroup JPEG_Exported_Constants JPEG Exported Constants 00207 * @{ 00208 */ 00209 00210 /** @defgroup JPEG_Error_Code_definition JPEG Error Code definition 00211 * @brief JPEG Error Code definition 00212 * @{ 00213 */ 00214 00215 #define HAL_JPEG_ERROR_NONE ((uint32_t)0x00000000U) /*!< No error */ 00216 #define HAL_JPEG_ERROR_HUFF_TABLE ((uint32_t)0x00000001U) /*!< HUffman Table programming error */ 00217 #define HAL_JPEG_ERROR_QUANT_TABLE ((uint32_t)0x00000002U) /*!< Quantization Table programming error */ 00218 #define HAL_JPEG_ERROR_DMA ((uint32_t)0x00000004U) /*!< DMA transfer error */ 00219 #define HAL_JPEG_ERROR_TIMEOUT ((uint32_t)0x00000008U) /*!< Timeout error */ 00220 #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1) 00221 #define HAL_JPEG_ERROR_INVALID_CALLBACK ((uint32_t)0x00000010U) /*!< Invalid Callback error */ 00222 #endif /* USE_HAL_JPEG_REGISTER_CALLBACKS */ 00223 /** 00224 * @} 00225 */ 00226 00227 /** @defgroup JPEG_Quantization_Table_Size JPEG Quantization Table Size 00228 * @brief JPEG Quantization Table Size 00229 * @{ 00230 */ 00231 #define JPEG_QUANT_TABLE_SIZE ((uint32_t)64U) /*!< JPEG Quantization Table Size in bytes */ 00232 /** 00233 * @} 00234 */ 00235 00236 00237 /** @defgroup JPEG_ColorSpace JPEG ColorSpace 00238 * @brief JPEG Color Space 00239 * @{ 00240 */ 00241 #define JPEG_GRAYSCALE_COLORSPACE ((uint32_t)0x00000000U) 00242 #define JPEG_YCBCR_COLORSPACE JPEG_CONFR1_COLORSPACE_0 00243 #define JPEG_CMYK_COLORSPACE JPEG_CONFR1_COLORSPACE 00244 00245 00246 /** 00247 * @} 00248 */ 00249 00250 00251 /** @defgroup JPEG_ChromaSubsampling JPEG Chrominance Sampling 00252 * @brief JPEG Chrominance Sampling 00253 * @{ 00254 */ 00255 #define JPEG_444_SUBSAMPLING ((uint32_t)0x00000000U) /*!< Chroma Subsampling 4:4:4 */ 00256 #define JPEG_420_SUBSAMPLING ((uint32_t)0x00000001U) /*!< Chroma Subsampling 4:2:0 */ 00257 #define JPEG_422_SUBSAMPLING ((uint32_t)0x00000002U) /*!< Chroma Subsampling 4:2:2 */ 00258 00259 /** 00260 * @} 00261 */ 00262 00263 /** @defgroup JPEG_ImageQuality JPEG Image Quality 00264 * @brief JPEG Min and Max Image Quality 00265 * @{ 00266 */ 00267 #define JPEG_IMAGE_QUALITY_MIN ((uint32_t)1U) /*!< Minimum JPEG quality */ 00268 #define JPEG_IMAGE_QUALITY_MAX ((uint32_t)100U) /*!< Maximum JPEG quality */ 00269 00270 /** 00271 * @} 00272 */ 00273 00274 /** @defgroup JPEG_Interrupt_configuration_definition JPEG Interrupt configuration definition 00275 * @brief JPEG Interrupt definition 00276 * @{ 00277 */ 00278 #define JPEG_IT_IFT ((uint32_t)JPEG_CR_IFTIE) /*!< Input FIFO Threshold Interrupt */ 00279 #define JPEG_IT_IFNF ((uint32_t)JPEG_CR_IFNFIE) /*!< Input FIFO Not Full Interrupt */ 00280 #define JPEG_IT_OFT ((uint32_t)JPEG_CR_OFTIE) /*!< Output FIFO Threshold Interrupt */ 00281 #define JPEG_IT_OFNE ((uint32_t)JPEG_CR_OFTIE) /*!< Output FIFO Not Empty Interrupt */ 00282 #define JPEG_IT_EOC ((uint32_t)JPEG_CR_EOCIE) /*!< End of Conversion Interrupt */ 00283 #define JPEG_IT_HPD ((uint32_t)JPEG_CR_HPDIE) /*!< Header Parsing Done Interrupt */ 00284 /** 00285 * @} 00286 */ 00287 00288 /** @defgroup JPEG_Flag_definition JPEG Flag definition 00289 * @brief JPEG Flags definition 00290 * @{ 00291 */ 00292 #define JPEG_FLAG_IFTF ((uint32_t)JPEG_SR_IFTF) /*!< Input FIFO is not full and is bellow its threshold flag */ 00293 #define JPEG_FLAG_IFNFF ((uint32_t)JPEG_SR_IFNFF) /*!< Input FIFO Not Full Flag, a data can be written */ 00294 #define JPEG_FLAG_OFTF ((uint32_t)JPEG_SR_OFTF) /*!< Output FIFO is not empty and has reach its threshold */ 00295 #define JPEG_FLAG_OFNEF ((uint32_t)JPEG_SR_OFNEF) /*!< Output FIFO is not empty, a data is available */ 00296 #define JPEG_FLAG_EOCF ((uint32_t)JPEG_SR_EOCF) /*!< JPEG Codec core has finished the encoding or the decoding process and than last data has been sent to the output FIFO */ 00297 #define JPEG_FLAG_HPDF ((uint32_t)JPEG_SR_HPDF) /*!< JPEG Codec has finished the parsing of the headers and the internal registers have been updated */ 00298 #define JPEG_FLAG_COF ((uint32_t)JPEG_SR_COF) /*!< JPEG Codec operation on going flag*/ 00299 00300 #define JPEG_FLAG_ALL ((uint32_t)0x000000FEU) /*!< JPEG Codec All previous flag*/ 00301 /** 00302 * @} 00303 */ 00304 00305 /** @defgroup JPEG_PROCESS_PAUSE_RESUME_definition JPEG Process Pause Resume definition 00306 * @brief JPEG process pause, resume definition 00307 * @{ 00308 */ 00309 #define JPEG_PAUSE_RESUME_INPUT ((uint32_t)0x00000001U) /*!< Pause/Resume Input FIFO Xfer*/ 00310 #define JPEG_PAUSE_RESUME_OUTPUT ((uint32_t)0x00000002U) /*!< Pause/Resume Output FIFO Xfer*/ 00311 #define JPEG_PAUSE_RESUME_INPUT_OUTPUT ((uint32_t)0x00000003U) /*!< Pause/Resume Input and Output FIFO Xfer*/ 00312 /** 00313 * @} 00314 */ 00315 00316 /** 00317 * @} 00318 */ 00319 /* Exported macro ------------------------------------------------------------*/ 00320 00321 /** @defgroup JPEG_Exported_Macros JPEG Exported Macros 00322 * @{ 00323 */ 00324 00325 /** @brief Reset JPEG handle state 00326 * @param __HANDLE__ specifies the JPEG handle. 00327 * @retval None 00328 */ 00329 #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1) 00330 #define __HAL_JPEG_RESET_HANDLE_STATE(__HANDLE__) do{\ 00331 (__HANDLE__)->State = HAL_JPEG_STATE_RESET;\ 00332 (__HANDLE__)->MspInitCallback = NULL;\ 00333 (__HANDLE__)->MspDeInitCallback = NULL;\ 00334 }while(0) 00335 #else 00336 #define __HAL_JPEG_RESET_HANDLE_STATE(__HANDLE__) ( (__HANDLE__)->State = HAL_JPEG_STATE_RESET) 00337 #endif /* USE_HAL_JPEG_REGISTER_CALLBACKS */ 00338 00339 00340 /** 00341 * @brief Enable the JPEG peripheral. 00342 * @param __HANDLE__ specifies the JPEG handle. 00343 * @retval None 00344 */ 00345 #define __HAL_JPEG_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR |= JPEG_CR_JCEN) 00346 00347 /** 00348 * @brief Disable the JPEG peripheral. 00349 * @param __HANDLE__ specifies the JPEG handle. 00350 * @retval None 00351 */ 00352 #define __HAL_JPEG_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR &= ~JPEG_CR_JCEN) 00353 00354 00355 /** 00356 * @brief Check the specified JPEG status flag. 00357 * @param __HANDLE__ specifies the JPEG handle. 00358 * @param __FLAG__ specifies the flag to check 00359 * This parameter can be one of the following values: 00360 * @arg JPEG_FLAG_IFTF : The input FIFO is not full and is bellow its threshold flag 00361 * @arg JPEG_FLAG_IFNFF : The input FIFO Not Full Flag, a data can be written 00362 * @arg JPEG_FLAG_OFTF : The output FIFO is not empty and has reach its threshold 00363 * @arg JPEG_FLAG_OFNEF : The output FIFO is not empty, a data is available 00364 * @arg JPEG_FLAG_EOCF : JPEG Codec core has finished the encoding or the decoding process 00365 * and than last data has been sent to the output FIFO 00366 * @arg JPEG_FLAG_HPDF : JPEG Codec has finished the parsing of the headers 00367 * and the internal registers have been updated 00368 * @arg JPEG_FLAG_COF : JPEG Codec operation on going flag 00369 * 00370 * @retval __HAL_JPEG_GET_FLAG : returns The new state of __FLAG__ (TRUE or FALSE) 00371 */ 00372 00373 #define __HAL_JPEG_GET_FLAG(__HANDLE__,__FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__))) 00374 00375 /** 00376 * @brief Clear the specified JPEG status flag. 00377 * @param __HANDLE__ specifies the JPEG handle. 00378 * @param __FLAG__ specifies the flag to clear 00379 * This parameter can be one of the following values: 00380 * @arg JPEG_FLAG_EOCF : JPEG Codec core has finished the encoding or the decoding process 00381 * and than last data has been sent to the output FIFO 00382 * @arg JPEG_FLAG_HPDF : JPEG Codec has finished the parsing of the headers 00383 * @retval None 00384 */ 00385 00386 #define __HAL_JPEG_CLEAR_FLAG(__HANDLE__,__FLAG__) (((__HANDLE__)->Instance->CFR |= ((__FLAG__) & (JPEG_FLAG_EOCF | JPEG_FLAG_HPDF)))) 00387 00388 00389 /** 00390 * @brief Enable Interrupt. 00391 * @param __HANDLE__ specifies the JPEG handle. 00392 * @param __INTERRUPT__ specifies the interrupt to enable 00393 * This parameter can be one of the following values: 00394 * @arg JPEG_IT_IFT : Input FIFO Threshold Interrupt 00395 * @arg JPEG_IT_IFNF : Input FIFO Not Full Interrupt 00396 * @arg JPEG_IT_OFT : Output FIFO Threshold Interrupt 00397 * @arg JPEG_IT_OFNE : Output FIFO Not empty Interrupt 00398 * @arg JPEG_IT_EOC : End of Conversion Interrupt 00399 * @arg JPEG_IT_HPD : Header Parsing Done Interrupt 00400 * 00401 * @retval No return 00402 */ 00403 #define __HAL_JPEG_ENABLE_IT(__HANDLE__,__INTERRUPT__) ((__HANDLE__)->Instance->CR |= (__INTERRUPT__) ) 00404 00405 /** 00406 * @brief Disable Interrupt. 00407 * @param __HANDLE__ specifies the JPEG handle. 00408 * @param __INTERRUPT__ specifies the interrupt to disable 00409 * This parameter can be one of the following values: 00410 * @arg JPEG_IT_IFT : Input FIFO Threshold Interrupt 00411 * @arg JPEG_IT_IFNF : Input FIFO Not Full Interrupt 00412 * @arg JPEG_IT_OFT : Output FIFO Threshold Interrupt 00413 * @arg JPEG_IT_OFNE : Output FIFO Not empty Interrupt 00414 * @arg JPEG_IT_EOC : End of Conversion Interrupt 00415 * @arg JPEG_IT_HPD : Header Parsing Done Interrupt 00416 * 00417 * @note To disable an IT we must use MODIFY_REG macro to avoid writing "1" to the FIFO flush bits 00418 * located in the same IT enable register (CR register). 00419 * @retval No return 00420 */ 00421 #define __HAL_JPEG_DISABLE_IT(__HANDLE__,__INTERRUPT__) MODIFY_REG((__HANDLE__)->Instance->CR, (__INTERRUPT__), 0UL) 00422 00423 00424 /** 00425 * @brief Get Interrupt state. 00426 * @param __HANDLE__ specifies the JPEG handle. 00427 * @param __INTERRUPT__ specifies the interrupt to check 00428 * This parameter can be one of the following values: 00429 * @arg JPEG_IT_IFT : Input FIFO Threshold Interrupt 00430 * @arg JPEG_IT_IFNF : Input FIFO Not Full Interrupt 00431 * @arg JPEG_IT_OFT : Output FIFO Threshold Interrupt 00432 * @arg JPEG_IT_OFNE : Output FIFO Not empty Interrupt 00433 * @arg JPEG_IT_EOC : End of Conversion Interrupt 00434 * @arg JPEG_IT_HPD : Header Parsing Done Interrupt 00435 * 00436 * @retval returns The new state of __INTERRUPT__ (Enabled or disabled) 00437 */ 00438 #define __HAL_JPEG_GET_IT_SOURCE(__HANDLE__,__INTERRUPT__) ((__HANDLE__)->Instance->CR & (__INTERRUPT__)) 00439 00440 /** 00441 * @} 00442 */ 00443 00444 /* Exported functions --------------------------------------------------------*/ 00445 /** @addtogroup JPEG_Exported_Functions 00446 * @{ 00447 */ 00448 00449 /** @addtogroup JPEG_Exported_Functions_Group1 00450 * @{ 00451 */ 00452 /* Initialization/de-initialization functions ********************************/ 00453 HAL_StatusTypeDef HAL_JPEG_Init(JPEG_HandleTypeDef *hjpeg); 00454 HAL_StatusTypeDef HAL_JPEG_DeInit(JPEG_HandleTypeDef *hjpeg); 00455 void HAL_JPEG_MspInit(JPEG_HandleTypeDef *hjpeg); 00456 void HAL_JPEG_MspDeInit(JPEG_HandleTypeDef *hjpeg); 00457 00458 #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1) 00459 HAL_StatusTypeDef HAL_JPEG_RegisterCallback(JPEG_HandleTypeDef *hjpeg, HAL_JPEG_CallbackIDTypeDef CallbackID, 00460 pJPEG_CallbackTypeDef pCallback); 00461 HAL_StatusTypeDef HAL_JPEG_UnRegisterCallback(JPEG_HandleTypeDef *hjpeg, HAL_JPEG_CallbackIDTypeDef CallbackID); 00462 00463 HAL_StatusTypeDef HAL_JPEG_RegisterInfoReadyCallback(JPEG_HandleTypeDef *hjpeg, 00464 pJPEG_InfoReadyCallbackTypeDef pCallback); 00465 HAL_StatusTypeDef HAL_JPEG_UnRegisterInfoReadyCallback(JPEG_HandleTypeDef *hjpeg); 00466 00467 HAL_StatusTypeDef HAL_JPEG_RegisterGetDataCallback(JPEG_HandleTypeDef *hjpeg, pJPEG_GetDataCallbackTypeDef pCallback); 00468 HAL_StatusTypeDef HAL_JPEG_UnRegisterGetDataCallback(JPEG_HandleTypeDef *hjpeg); 00469 00470 HAL_StatusTypeDef HAL_JPEG_RegisterDataReadyCallback(JPEG_HandleTypeDef *hjpeg, 00471 pJPEG_DataReadyCallbackTypeDef pCallback); 00472 HAL_StatusTypeDef HAL_JPEG_UnRegisterDataReadyCallback(JPEG_HandleTypeDef *hjpeg); 00473 00474 #endif /* USE_HAL_JPEG_REGISTER_CALLBACKS */ 00475 00476 /** 00477 * @} 00478 */ 00479 00480 /** @addtogroup JPEG_Exported_Functions_Group2 00481 * @{ 00482 */ 00483 /* Encoding/Decoding Configuration functions ********************************/ 00484 HAL_StatusTypeDef HAL_JPEG_ConfigEncoding(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pConf); 00485 HAL_StatusTypeDef HAL_JPEG_GetInfo(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo); 00486 HAL_StatusTypeDef HAL_JPEG_EnableHeaderParsing(JPEG_HandleTypeDef *hjpeg); 00487 HAL_StatusTypeDef HAL_JPEG_DisableHeaderParsing(JPEG_HandleTypeDef *hjpeg); 00488 HAL_StatusTypeDef HAL_JPEG_SetUserQuantTables(JPEG_HandleTypeDef *hjpeg, uint8_t *QTable0, uint8_t *QTable1, 00489 uint8_t *QTable2, uint8_t *QTable3); 00490 00491 /** 00492 * @} 00493 */ 00494 00495 /** @addtogroup JPEG_Exported_Functions_Group3 00496 * @{ 00497 */ 00498 /* JPEG processing functions **************************************/ 00499 HAL_StatusTypeDef HAL_JPEG_Encode(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength, 00500 uint8_t *pDataOut, uint32_t OutDataLength, uint32_t Timeout); 00501 HAL_StatusTypeDef HAL_JPEG_Decode(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataIn, uint32_t InDataLength, 00502 uint8_t *pDataOutMCU, uint32_t OutDataLength, uint32_t Timeout); 00503 HAL_StatusTypeDef HAL_JPEG_Encode_IT(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength, 00504 uint8_t *pDataOut, uint32_t OutDataLength); 00505 HAL_StatusTypeDef HAL_JPEG_Decode_IT(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataIn, uint32_t InDataLength, 00506 uint8_t *pDataOutMCU, uint32_t OutDataLength); 00507 HAL_StatusTypeDef HAL_JPEG_Encode_DMA(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength, 00508 uint8_t *pDataOut, uint32_t OutDataLength); 00509 HAL_StatusTypeDef HAL_JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataIn, uint32_t InDataLength, 00510 uint8_t *pDataOutMCU, uint32_t OutDataLength); 00511 HAL_StatusTypeDef HAL_JPEG_Pause(JPEG_HandleTypeDef *hjpeg, uint32_t XferSelection); 00512 HAL_StatusTypeDef HAL_JPEG_Resume(JPEG_HandleTypeDef *hjpeg, uint32_t XferSelection); 00513 void HAL_JPEG_ConfigInputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewInputBuffer, uint32_t InDataLength); 00514 void HAL_JPEG_ConfigOutputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewOutputBuffer, uint32_t OutDataLength); 00515 HAL_StatusTypeDef HAL_JPEG_Abort(JPEG_HandleTypeDef *hjpeg); 00516 00517 /** 00518 * @} 00519 */ 00520 00521 /** @addtogroup JPEG_Exported_Functions_Group4 00522 * @{ 00523 */ 00524 /* JPEG Decode/Encode callback functions ********************************************************/ 00525 void HAL_JPEG_InfoReadyCallback(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo); 00526 void HAL_JPEG_EncodeCpltCallback(JPEG_HandleTypeDef *hjpeg); 00527 void HAL_JPEG_DecodeCpltCallback(JPEG_HandleTypeDef *hjpeg); 00528 void HAL_JPEG_ErrorCallback(JPEG_HandleTypeDef *hjpeg); 00529 void HAL_JPEG_GetDataCallback(JPEG_HandleTypeDef *hjpeg, uint32_t NbDecodedData); 00530 void HAL_JPEG_DataReadyCallback(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, uint32_t OutDataLength); 00531 00532 /** 00533 * @} 00534 */ 00535 00536 /** @addtogroup JPEG_Exported_Functions_Group5 00537 * @{ 00538 */ 00539 /* JPEG IRQ handler management ******************************************************/ 00540 void HAL_JPEG_IRQHandler(JPEG_HandleTypeDef *hjpeg); 00541 00542 /** 00543 * @} 00544 */ 00545 00546 /** @addtogroup JPEG_Exported_Functions_Group6 00547 * @{ 00548 */ 00549 /* Peripheral State and Error functions ************************************************/ 00550 HAL_JPEG_STATETypeDef HAL_JPEG_GetState(JPEG_HandleTypeDef *hjpeg); 00551 uint32_t HAL_JPEG_GetError(JPEG_HandleTypeDef *hjpeg); 00552 00553 /** 00554 * @} 00555 */ 00556 00557 /** 00558 * @} 00559 */ 00560 00561 /* Private types -------------------------------------------------------------*/ 00562 /** @defgroup JPEG_Private_Types JPEG Private Types 00563 * @{ 00564 */ 00565 00566 /** 00567 * @} 00568 */ 00569 00570 /* Private defines -----------------------------------------------------------*/ 00571 /** @defgroup JPEG_Private_Defines JPEG Private Defines 00572 * @{ 00573 */ 00574 00575 /** 00576 * @} 00577 */ 00578 00579 /* Private variables ---------------------------------------------------------*/ 00580 /** @defgroup JPEG_Private_Variables JPEG Private Variables 00581 * @{ 00582 */ 00583 00584 /** 00585 * @} 00586 */ 00587 00588 /* Private constants ---------------------------------------------------------*/ 00589 /** @defgroup JPEG_Private_Constants JPEG Private Constants 00590 * @{ 00591 */ 00592 00593 /** 00594 * @} 00595 */ 00596 00597 /* Private macros ------------------------------------------------------------*/ 00598 /** @defgroup JPEG_Private_Macros JPEG Private Macros 00599 * @{ 00600 */ 00601 00602 #define IS_JPEG_CHROMASUBSAMPLING(SUBSAMPLING) (((SUBSAMPLING) == JPEG_444_SUBSAMPLING) || \ 00603 ((SUBSAMPLING) == JPEG_420_SUBSAMPLING) || \ 00604 ((SUBSAMPLING) == JPEG_422_SUBSAMPLING)) 00605 00606 #define IS_JPEG_IMAGE_QUALITY(NUMBER) (((NUMBER) >= JPEG_IMAGE_QUALITY_MIN) && ((NUMBER) <= JPEG_IMAGE_QUALITY_MAX)) 00607 00608 #define IS_JPEG_COLORSPACE(COLORSPACE) (((COLORSPACE) == JPEG_GRAYSCALE_COLORSPACE) || \ 00609 ((COLORSPACE) == JPEG_YCBCR_COLORSPACE) || \ 00610 ((COLORSPACE) == JPEG_CMYK_COLORSPACE)) 00611 00612 #define IS_JPEG_PAUSE_RESUME_STATE(VALUE) (((VALUE) == JPEG_PAUSE_RESUME_INPUT) || \ 00613 ((VALUE) == JPEG_PAUSE_RESUME_OUTPUT)|| \ 00614 ((VALUE) == JPEG_PAUSE_RESUME_INPUT_OUTPUT)) 00615 00616 /** 00617 * @} 00618 */ 00619 00620 /* Private functions prototypes ----------------------------------------------*/ 00621 /** @defgroup JPEG_Private_Functions_Prototypes JPEG Private Functions Prototypes 00622 * @{ 00623 */ 00624 00625 /** 00626 * @} 00627 */ 00628 00629 /* Private functions ---------------------------------------------------------*/ 00630 /** @defgroup JPEG_Private_Functions JPEG Private Functions 00631 * @{ 00632 */ 00633 00634 /** 00635 * @} 00636 */ 00637 00638 /** 00639 * @} 00640 */ 00641 00642 /** 00643 * @} 00644 */ 00645 00646 #endif /* JPEG */ 00647 00648 #ifdef __cplusplus 00649 } 00650 #endif 00651 00652 #endif /* STM32H7xx_HAL_JPEG_H */ 00653
1.7.6.1