You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

656 lines
25 KiB

  1. /**
  2. ******************************************************************************
  3. * @file stm32h7xx_hal_jpeg.h
  4. * @author MCD Application Team
  5. * @brief Header file of JPEG HAL module.
  6. ******************************************************************************
  7. * @attention
  8. *
  9. * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
  10. * All rights reserved.</center></h2>
  11. *
  12. * This software component is licensed by ST under BSD 3-Clause license,
  13. * the "License"; You may not use this file except in compliance with the
  14. * License. You may obtain a copy of the License at:
  15. * opensource.org/licenses/BSD-3-Clause
  16. *
  17. ******************************************************************************
  18. */
  19. /* Define to prevent recursive inclusion -------------------------------------*/
  20. #ifndef STM32H7xx_HAL_JPEG_H
  21. #define STM32H7xx_HAL_JPEG_H
  22. #ifdef __cplusplus
  23. extern "C" {
  24. #endif
  25. /* Includes ------------------------------------------------------------------*/
  26. #include "stm32h7xx_hal_def.h"
  27. #if defined (JPEG)
  28. /** @addtogroup STM32H7xx_HAL_Driver
  29. * @{
  30. */
  31. /** @addtogroup JPEG
  32. * @{
  33. */
  34. /* Exported types ------------------------------------------------------------*/
  35. /** @defgroup JPEG_Exported_Types JPEG Exported Types
  36. * @{
  37. */
  38. /** @defgroup JPEG_Configuration_Structure_definition JPEG Configuration for encoding Structure definition
  39. * @brief JPEG encoding configuration Structure definition
  40. * @{
  41. */
  42. typedef struct
  43. {
  44. uint32_t ColorSpace; /*!< Image Color space : gray-scale, YCBCR, RGB or CMYK
  45. This parameter can be a value of @ref JPEG_ColorSpace */
  46. 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
  47. This parameter can be a value of @ref JPEG_ChromaSubsampling */
  48. uint32_t ImageHeight; /*!< Image height : number of lines */
  49. uint32_t ImageWidth; /*!< Image width : number of pixels per line */
  50. uint32_t ImageQuality; /*!< Quality of the JPEG encoding : from 1 to 100 */
  51. } JPEG_ConfTypeDef;
  52. /**
  53. * @}
  54. */
  55. /** @defgroup HAL_JPEG_state_structure_definition HAL JPEG state structure definition
  56. * @brief HAL JPEG State structure definition
  57. * @{
  58. */
  59. typedef enum
  60. {
  61. HAL_JPEG_STATE_RESET = 0x00U, /*!< JPEG not yet initialized or disabled */
  62. HAL_JPEG_STATE_READY = 0x01U, /*!< JPEG initialized and ready for use */
  63. HAL_JPEG_STATE_BUSY = 0x02U, /*!< JPEG internal processing is ongoing */
  64. HAL_JPEG_STATE_BUSY_ENCODING = 0x03U, /*!< JPEG encoding processing is ongoing */
  65. HAL_JPEG_STATE_BUSY_DECODING = 0x04U, /*!< JPEG decoding processing is ongoing */
  66. HAL_JPEG_STATE_TIMEOUT = 0x05U, /*!< JPEG timeout state */
  67. HAL_JPEG_STATE_ERROR = 0x06U /*!< JPEG error state */
  68. } HAL_JPEG_STATETypeDef;
  69. /**
  70. * @}
  71. */
  72. /** @defgroup JPEG_handle_Structure_definition JPEG handle Structure definition
  73. * @brief JPEG handle Structure definition
  74. * @{
  75. */
  76. #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1)
  77. typedef struct __JPEG_HandleTypeDef
  78. #else
  79. typedef struct
  80. #endif /* (USE_HAL_JPEG_REGISTER_CALLBACKS) */
  81. {
  82. JPEG_TypeDef *Instance; /*!< JPEG peripheral register base address */
  83. JPEG_ConfTypeDef Conf; /*!< Current JPEG encoding/decoding parameters */
  84. uint8_t *pJpegInBuffPtr; /*!< Pointer to JPEG processing (encoding, decoding,...) input buffer */
  85. uint8_t *pJpegOutBuffPtr; /*!< Pointer to JPEG processing (encoding, decoding,...) output buffer */
  86. __IO uint32_t JpegInCount; /*!< Internal Counter of input data */
  87. __IO uint32_t JpegOutCount; /*!< Internal Counter of output data */
  88. uint32_t InDataLength; /*!< Input Buffer Length in Bytes */
  89. uint32_t OutDataLength; /*!< Output Buffer Length in Bytes */
  90. MDMA_HandleTypeDef *hdmain; /*!< JPEG In MDMA handle parameters */
  91. MDMA_HandleTypeDef *hdmaout; /*!< JPEG Out MDMA handle parameters */
  92. uint8_t CustomQuanTable; /*!< If set to 1 specify that user customized quantization tables are used */
  93. uint8_t *QuantTable0; /*!< Basic Quantization Table for component 0 */
  94. uint8_t *QuantTable1; /*!< Basic Quantization Table for component 1 */
  95. uint8_t *QuantTable2; /*!< Basic Quantization Table for component 2 */
  96. uint8_t *QuantTable3; /*!< Basic Quantization Table for component 3 */
  97. HAL_LockTypeDef Lock; /*!< JPEG locking object */
  98. __IO HAL_JPEG_STATETypeDef State; /*!< JPEG peripheral state */
  99. __IO uint32_t ErrorCode; /*!< JPEG Error code */
  100. __IO uint32_t Context; /*!< JPEG Internal context */
  101. #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1)
  102. void (*InfoReadyCallback)(struct __JPEG_HandleTypeDef *hjpeg,
  103. JPEG_ConfTypeDef *pInfo); /*!< JPEG Info ready callback */
  104. void (*EncodeCpltCallback)(struct __JPEG_HandleTypeDef
  105. *hjpeg); /*!< JPEG Encode complete callback */
  106. void (*DecodeCpltCallback)(struct __JPEG_HandleTypeDef
  107. *hjpeg); /*!< JPEG Decode complete callback */
  108. void (*ErrorCallback)(struct __JPEG_HandleTypeDef
  109. *hjpeg); /*!< JPEG Error callback */
  110. void (*GetDataCallback)(struct __JPEG_HandleTypeDef *hjpeg,
  111. uint32_t NbDecodedData); /*!< JPEG Get Data callback */
  112. void (*DataReadyCallback)(struct __JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut,
  113. uint32_t OutDataLength); /*!< JPEG Data ready callback */
  114. void (* MspInitCallback)(struct __JPEG_HandleTypeDef *hjpeg); /*!< JPEG Msp Init callback */
  115. void (* MspDeInitCallback)(struct __JPEG_HandleTypeDef
  116. *hjpeg); /*!< JPEG Msp DeInit callback */
  117. #endif /* (USE_HAL_JPEG_REGISTER_CALLBACKS) */
  118. } JPEG_HandleTypeDef;
  119. /**
  120. * @}
  121. */
  122. #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1)
  123. /** @defgroup HAL_JPEG_Callback_ID_enumeration_definition HAL JPEG Callback ID enumeration definition
  124. * @brief HAL JPEG Callback ID enumeration definition
  125. * @{
  126. */
  127. typedef enum
  128. {
  129. HAL_JPEG_ENCODE_CPLT_CB_ID = 0x01U, /*!< JPEG Encode Complete callback ID */
  130. HAL_JPEG_DECODE_CPLT_CB_ID = 0x02U, /*!< JPEG Decode Complete callback ID */
  131. HAL_JPEG_ERROR_CB_ID = 0x03U, /*!< JPEG Error callback ID */
  132. HAL_JPEG_MSPINIT_CB_ID = 0x04U, /*!< JPEG MspInit callback ID */
  133. HAL_JPEG_MSPDEINIT_CB_ID = 0x05U /*!< JPEG MspDeInit callback ID */
  134. } HAL_JPEG_CallbackIDTypeDef;
  135. /**
  136. * @}
  137. */
  138. /** @defgroup HAL_JPEG_Callback_pointer_definition HAL JPEG Callback pointer definition
  139. * @brief HAL JPEG Callback pointer definition
  140. * @{
  141. */
  142. typedef void (*pJPEG_CallbackTypeDef)(JPEG_HandleTypeDef *hjpeg); /*!< pointer to a common JPEG callback function */
  143. typedef void (*pJPEG_InfoReadyCallbackTypeDef)(JPEG_HandleTypeDef *hjpeg,
  144. JPEG_ConfTypeDef *pInfo); /*!< pointer to an Info ready JPEG callback function */
  145. typedef void (*pJPEG_GetDataCallbackTypeDef)(JPEG_HandleTypeDef *hjpeg,
  146. uint32_t NbDecodedData); /*!< pointer to a Get data JPEG callback function */
  147. typedef void (*pJPEG_DataReadyCallbackTypeDef)(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut,
  148. uint32_t OutDataLength); /*!< pointer to a Data ready JPEG callback function */
  149. /**
  150. * @}
  151. */
  152. #endif /* USE_HAL_JPEG_REGISTER_CALLBACKS */
  153. /**
  154. * @}
  155. */
  156. /* Exported constants --------------------------------------------------------*/
  157. /** @defgroup JPEG_Exported_Constants JPEG Exported Constants
  158. * @{
  159. */
  160. /** @defgroup JPEG_Error_Code_definition JPEG Error Code definition
  161. * @brief JPEG Error Code definition
  162. * @{
  163. */
  164. #define HAL_JPEG_ERROR_NONE ((uint32_t)0x00000000U) /*!< No error */
  165. #define HAL_JPEG_ERROR_HUFF_TABLE ((uint32_t)0x00000001U) /*!< HUffman Table programming error */
  166. #define HAL_JPEG_ERROR_QUANT_TABLE ((uint32_t)0x00000002U) /*!< Quantization Table programming error */
  167. #define HAL_JPEG_ERROR_DMA ((uint32_t)0x00000004U) /*!< DMA transfer error */
  168. #define HAL_JPEG_ERROR_TIMEOUT ((uint32_t)0x00000008U) /*!< Timeout error */
  169. #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1)
  170. #define HAL_JPEG_ERROR_INVALID_CALLBACK ((uint32_t)0x00000010U) /*!< Invalid Callback error */
  171. #endif /* USE_HAL_JPEG_REGISTER_CALLBACKS */
  172. /**
  173. * @}
  174. */
  175. /** @defgroup JPEG_Quantization_Table_Size JPEG Quantization Table Size
  176. * @brief JPEG Quantization Table Size
  177. * @{
  178. */
  179. #define JPEG_QUANT_TABLE_SIZE ((uint32_t)64U) /*!< JPEG Quantization Table Size in bytes */
  180. /**
  181. * @}
  182. */
  183. /** @defgroup JPEG_ColorSpace JPEG ColorSpace
  184. * @brief JPEG Color Space
  185. * @{
  186. */
  187. #define JPEG_GRAYSCALE_COLORSPACE ((uint32_t)0x00000000U)
  188. #define JPEG_YCBCR_COLORSPACE JPEG_CONFR1_COLORSPACE_0
  189. #define JPEG_CMYK_COLORSPACE JPEG_CONFR1_COLORSPACE
  190. /**
  191. * @}
  192. */
  193. /** @defgroup JPEG_ChromaSubsampling JPEG Chrominance Sampling
  194. * @brief JPEG Chrominance Sampling
  195. * @{
  196. */
  197. #define JPEG_444_SUBSAMPLING ((uint32_t)0x00000000U) /*!< Chroma Subsampling 4:4:4 */
  198. #define JPEG_420_SUBSAMPLING ((uint32_t)0x00000001U) /*!< Chroma Subsampling 4:2:0 */
  199. #define JPEG_422_SUBSAMPLING ((uint32_t)0x00000002U) /*!< Chroma Subsampling 4:2:2 */
  200. /**
  201. * @}
  202. */
  203. /** @defgroup JPEG_ImageQuality JPEG Image Quality
  204. * @brief JPEG Min and Max Image Quality
  205. * @{
  206. */
  207. #define JPEG_IMAGE_QUALITY_MIN ((uint32_t)1U) /*!< Minimum JPEG quality */
  208. #define JPEG_IMAGE_QUALITY_MAX ((uint32_t)100U) /*!< Maximum JPEG quality */
  209. /**
  210. * @}
  211. */
  212. /** @defgroup JPEG_Interrupt_configuration_definition JPEG Interrupt configuration definition
  213. * @brief JPEG Interrupt definition
  214. * @{
  215. */
  216. #define JPEG_IT_IFT ((uint32_t)JPEG_CR_IFTIE) /*!< Input FIFO Threshold Interrupt */
  217. #define JPEG_IT_IFNF ((uint32_t)JPEG_CR_IFNFIE) /*!< Input FIFO Not Full Interrupt */
  218. #define JPEG_IT_OFT ((uint32_t)JPEG_CR_OFTIE) /*!< Output FIFO Threshold Interrupt */
  219. #define JPEG_IT_OFNE ((uint32_t)JPEG_CR_OFTIE) /*!< Output FIFO Not Empty Interrupt */
  220. #define JPEG_IT_EOC ((uint32_t)JPEG_CR_EOCIE) /*!< End of Conversion Interrupt */
  221. #define JPEG_IT_HPD ((uint32_t)JPEG_CR_HPDIE) /*!< Header Parsing Done Interrupt */
  222. /**
  223. * @}
  224. */
  225. /** @defgroup JPEG_Flag_definition JPEG Flag definition
  226. * @brief JPEG Flags definition
  227. * @{
  228. */
  229. #define JPEG_FLAG_IFTF ((uint32_t)JPEG_SR_IFTF) /*!< Input FIFO is not full and is bellow its threshold flag */
  230. #define JPEG_FLAG_IFNFF ((uint32_t)JPEG_SR_IFNFF) /*!< Input FIFO Not Full Flag, a data can be written */
  231. #define JPEG_FLAG_OFTF ((uint32_t)JPEG_SR_OFTF) /*!< Output FIFO is not empty and has reach its threshold */
  232. #define JPEG_FLAG_OFNEF ((uint32_t)JPEG_SR_OFNEF) /*!< Output FIFO is not empty, a data is available */
  233. #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 */
  234. #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 */
  235. #define JPEG_FLAG_COF ((uint32_t)JPEG_SR_COF) /*!< JPEG Codec operation on going flag*/
  236. #define JPEG_FLAG_ALL ((uint32_t)0x000000FEU) /*!< JPEG Codec All previous flag*/
  237. /**
  238. * @}
  239. */
  240. /** @defgroup JPEG_PROCESS_PAUSE_RESUME_definition JPEG Process Pause Resume definition
  241. * @brief JPEG process pause, resume definition
  242. * @{
  243. */
  244. #define JPEG_PAUSE_RESUME_INPUT ((uint32_t)0x00000001U) /*!< Pause/Resume Input FIFO Xfer*/
  245. #define JPEG_PAUSE_RESUME_OUTPUT ((uint32_t)0x00000002U) /*!< Pause/Resume Output FIFO Xfer*/
  246. #define JPEG_PAUSE_RESUME_INPUT_OUTPUT ((uint32_t)0x00000003U) /*!< Pause/Resume Input and Output FIFO Xfer*/
  247. /**
  248. * @}
  249. */
  250. /**
  251. * @}
  252. */
  253. /* Exported macro ------------------------------------------------------------*/
  254. /** @defgroup JPEG_Exported_Macros JPEG Exported Macros
  255. * @{
  256. */
  257. /** @brief Reset JPEG handle state
  258. * @param __HANDLE__ specifies the JPEG handle.
  259. * @retval None
  260. */
  261. #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1)
  262. #define __HAL_JPEG_RESET_HANDLE_STATE(__HANDLE__) do{\
  263. (__HANDLE__)->State = HAL_JPEG_STATE_RESET;\
  264. (__HANDLE__)->MspInitCallback = NULL;\
  265. (__HANDLE__)->MspDeInitCallback = NULL;\
  266. }while(0)
  267. #else
  268. #define __HAL_JPEG_RESET_HANDLE_STATE(__HANDLE__) ( (__HANDLE__)->State = HAL_JPEG_STATE_RESET)
  269. #endif /* USE_HAL_JPEG_REGISTER_CALLBACKS */
  270. /**
  271. * @brief Enable the JPEG peripheral.
  272. * @param __HANDLE__ specifies the JPEG handle.
  273. * @retval None
  274. */
  275. #define __HAL_JPEG_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR |= JPEG_CR_JCEN)
  276. /**
  277. * @brief Disable the JPEG peripheral.
  278. * @param __HANDLE__ specifies the JPEG handle.
  279. * @retval None
  280. */
  281. #define __HAL_JPEG_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR &= ~JPEG_CR_JCEN)
  282. /**
  283. * @brief Check the specified JPEG status flag.
  284. * @param __HANDLE__ specifies the JPEG handle.
  285. * @param __FLAG__ specifies the flag to check
  286. * This parameter can be one of the following values:
  287. * @arg JPEG_FLAG_IFTF : The input FIFO is not full and is bellow its threshold flag
  288. * @arg JPEG_FLAG_IFNFF : The input FIFO Not Full Flag, a data can be written
  289. * @arg JPEG_FLAG_OFTF : The output FIFO is not empty and has reach its threshold
  290. * @arg JPEG_FLAG_OFNEF : The output FIFO is not empty, a data is available
  291. * @arg JPEG_FLAG_EOCF : JPEG Codec core has finished the encoding or the decoding process
  292. * and than last data has been sent to the output FIFO
  293. * @arg JPEG_FLAG_HPDF : JPEG Codec has finished the parsing of the headers
  294. * and the internal registers have been updated
  295. * @arg JPEG_FLAG_COF : JPEG Codec operation on going flag
  296. *
  297. * @retval __HAL_JPEG_GET_FLAG : returns The new state of __FLAG__ (TRUE or FALSE)
  298. */
  299. #define __HAL_JPEG_GET_FLAG(__HANDLE__,__FLAG__) (((__HANDLE__)->Instance->SR & (__FLAG__)))
  300. /**
  301. * @brief Clear the specified JPEG status flag.
  302. * @param __HANDLE__ specifies the JPEG handle.
  303. * @param __FLAG__ specifies the flag to clear
  304. * This parameter can be one of the following values:
  305. * @arg JPEG_FLAG_EOCF : JPEG Codec core has finished the encoding or the decoding process
  306. * and than last data has been sent to the output FIFO
  307. * @arg JPEG_FLAG_HPDF : JPEG Codec has finished the parsing of the headers
  308. * @retval None
  309. */
  310. #define __HAL_JPEG_CLEAR_FLAG(__HANDLE__,__FLAG__) (((__HANDLE__)->Instance->CFR |= ((__FLAG__) & (JPEG_FLAG_EOCF | JPEG_FLAG_HPDF))))
  311. /**
  312. * @brief Enable Interrupt.
  313. * @param __HANDLE__ specifies the JPEG handle.
  314. * @param __INTERRUPT__ specifies the interrupt to enable
  315. * This parameter can be one of the following values:
  316. * @arg JPEG_IT_IFT : Input FIFO Threshold Interrupt
  317. * @arg JPEG_IT_IFNF : Input FIFO Not Full Interrupt
  318. * @arg JPEG_IT_OFT : Output FIFO Threshold Interrupt
  319. * @arg JPEG_IT_OFNE : Output FIFO Not empty Interrupt
  320. * @arg JPEG_IT_EOC : End of Conversion Interrupt
  321. * @arg JPEG_IT_HPD : Header Parsing Done Interrupt
  322. *
  323. * @retval No retrun
  324. */
  325. #define __HAL_JPEG_ENABLE_IT(__HANDLE__,__INTERRUPT__) ((__HANDLE__)->Instance->CR |= (__INTERRUPT__) )
  326. /**
  327. * @brief Disable Interrupt.
  328. * @param __HANDLE__ specifies the JPEG handle.
  329. * @param __INTERRUPT__ specifies the interrupt to disable
  330. * This parameter can be one of the following values:
  331. * @arg JPEG_IT_IFT : Input FIFO Threshold Interrupt
  332. * @arg JPEG_IT_IFNF : Input FIFO Not Full Interrupt
  333. * @arg JPEG_IT_OFT : Output FIFO Threshold Interrupt
  334. * @arg JPEG_IT_OFNE : Output FIFO Not empty Interrupt
  335. * @arg JPEG_IT_EOC : End of Conversion Interrupt
  336. * @arg JPEG_IT_HPD : Header Parsing Done Interrupt
  337. *
  338. * @note To disable an IT we must use MODIFY_REG macro to avoid writing "1" to the FIFO flush bits
  339. * located in the same IT enable register (CR register).
  340. * @retval No retrun
  341. */
  342. #define __HAL_JPEG_DISABLE_IT(__HANDLE__,__INTERRUPT__) MODIFY_REG((__HANDLE__)->Instance->CR, (__INTERRUPT__), 0UL)
  343. /**
  344. * @brief Get Interrupt state.
  345. * @param __HANDLE__ specifies the JPEG handle.
  346. * @param __INTERRUPT__ specifies the interrupt to check
  347. * This parameter can be one of the following values:
  348. * @arg JPEG_IT_IFT : Input FIFO Threshold Interrupt
  349. * @arg JPEG_IT_IFNF : Input FIFO Not Full Interrupt
  350. * @arg JPEG_IT_OFT : Output FIFO Threshold Interrupt
  351. * @arg JPEG_IT_OFNE : Output FIFO Not empty Interrupt
  352. * @arg JPEG_IT_EOC : End of Conversion Interrupt
  353. * @arg JPEG_IT_HPD : Header Parsing Done Interrupt
  354. *
  355. * @retval returns The new state of __INTERRUPT__ (Enabled or disabled)
  356. */
  357. #define __HAL_JPEG_GET_IT_SOURCE(__HANDLE__,__INTERRUPT__) ((__HANDLE__)->Instance->CR & (__INTERRUPT__))
  358. /**
  359. * @}
  360. */
  361. /* Exported functions --------------------------------------------------------*/
  362. /** @addtogroup JPEG_Exported_Functions
  363. * @{
  364. */
  365. /** @addtogroup JPEG_Exported_Functions_Group1
  366. * @{
  367. */
  368. /* Initialization/de-initialization functions ********************************/
  369. HAL_StatusTypeDef HAL_JPEG_Init(JPEG_HandleTypeDef *hjpeg);
  370. HAL_StatusTypeDef HAL_JPEG_DeInit(JPEG_HandleTypeDef *hjpeg);
  371. void HAL_JPEG_MspInit(JPEG_HandleTypeDef *hjpeg);
  372. void HAL_JPEG_MspDeInit(JPEG_HandleTypeDef *hjpeg);
  373. #if (USE_HAL_JPEG_REGISTER_CALLBACKS == 1)
  374. HAL_StatusTypeDef HAL_JPEG_RegisterCallback(JPEG_HandleTypeDef *hjpeg, HAL_JPEG_CallbackIDTypeDef CallbackID,
  375. pJPEG_CallbackTypeDef pCallback);
  376. HAL_StatusTypeDef HAL_JPEG_UnRegisterCallback(JPEG_HandleTypeDef *hjpeg, HAL_JPEG_CallbackIDTypeDef CallbackID);
  377. HAL_StatusTypeDef HAL_JPEG_RegisterInfoReadyCallback(JPEG_HandleTypeDef *hjpeg,
  378. pJPEG_InfoReadyCallbackTypeDef pCallback);
  379. HAL_StatusTypeDef HAL_JPEG_UnRegisterInfoReadyCallback(JPEG_HandleTypeDef *hjpeg);
  380. HAL_StatusTypeDef HAL_JPEG_RegisterGetDataCallback(JPEG_HandleTypeDef *hjpeg, pJPEG_GetDataCallbackTypeDef pCallback);
  381. HAL_StatusTypeDef HAL_JPEG_UnRegisterGetDataCallback(JPEG_HandleTypeDef *hjpeg);
  382. HAL_StatusTypeDef HAL_JPEG_RegisterDataReadyCallback(JPEG_HandleTypeDef *hjpeg,
  383. pJPEG_DataReadyCallbackTypeDef pCallback);
  384. HAL_StatusTypeDef HAL_JPEG_UnRegisterDataReadyCallback(JPEG_HandleTypeDef *hjpeg);
  385. #endif /* USE_HAL_JPEG_REGISTER_CALLBACKS */
  386. /**
  387. * @}
  388. */
  389. /** @addtogroup JPEG_Exported_Functions_Group2
  390. * @{
  391. */
  392. /* Encoding/Decoding Configuration functions ********************************/
  393. HAL_StatusTypeDef HAL_JPEG_ConfigEncoding(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pConf);
  394. HAL_StatusTypeDef HAL_JPEG_GetInfo(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo);
  395. HAL_StatusTypeDef HAL_JPEG_EnableHeaderParsing(JPEG_HandleTypeDef *hjpeg);
  396. HAL_StatusTypeDef HAL_JPEG_DisableHeaderParsing(JPEG_HandleTypeDef *hjpeg);
  397. HAL_StatusTypeDef HAL_JPEG_SetUserQuantTables(JPEG_HandleTypeDef *hjpeg, uint8_t *QTable0, uint8_t *QTable1,
  398. uint8_t *QTable2, uint8_t *QTable3);
  399. /**
  400. * @}
  401. */
  402. /** @addtogroup JPEG_Exported_Functions_Group3
  403. * @{
  404. */
  405. /* JPEG processing functions **************************************/
  406. HAL_StatusTypeDef HAL_JPEG_Encode(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength,
  407. uint8_t *pDataOut, uint32_t OutDataLength, uint32_t Timeout);
  408. HAL_StatusTypeDef HAL_JPEG_Decode(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataIn, uint32_t InDataLength,
  409. uint8_t *pDataOutMCU, uint32_t OutDataLength, uint32_t Timeout);
  410. HAL_StatusTypeDef HAL_JPEG_Encode_IT(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength,
  411. uint8_t *pDataOut, uint32_t OutDataLength);
  412. HAL_StatusTypeDef HAL_JPEG_Decode_IT(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataIn, uint32_t InDataLength,
  413. uint8_t *pDataOutMCU, uint32_t OutDataLength);
  414. HAL_StatusTypeDef HAL_JPEG_Encode_DMA(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength,
  415. uint8_t *pDataOut, uint32_t OutDataLength);
  416. HAL_StatusTypeDef HAL_JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataIn, uint32_t InDataLength,
  417. uint8_t *pDataOutMCU, uint32_t OutDataLength);
  418. HAL_StatusTypeDef HAL_JPEG_Pause(JPEG_HandleTypeDef *hjpeg, uint32_t XferSelection);
  419. HAL_StatusTypeDef HAL_JPEG_Resume(JPEG_HandleTypeDef *hjpeg, uint32_t XferSelection);
  420. void HAL_JPEG_ConfigInputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewInputBuffer, uint32_t InDataLength);
  421. void HAL_JPEG_ConfigOutputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewOutputBuffer, uint32_t OutDataLength);
  422. HAL_StatusTypeDef HAL_JPEG_Abort(JPEG_HandleTypeDef *hjpeg);
  423. /**
  424. * @}
  425. */
  426. /** @addtogroup JPEG_Exported_Functions_Group4
  427. * @{
  428. */
  429. /* JPEG Decode/Encode callback functions ********************************************************/
  430. void HAL_JPEG_InfoReadyCallback(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo);
  431. void HAL_JPEG_EncodeCpltCallback(JPEG_HandleTypeDef *hjpeg);
  432. void HAL_JPEG_DecodeCpltCallback(JPEG_HandleTypeDef *hjpeg);
  433. void HAL_JPEG_ErrorCallback(JPEG_HandleTypeDef *hjpeg);
  434. void HAL_JPEG_GetDataCallback(JPEG_HandleTypeDef *hjpeg, uint32_t NbDecodedData);
  435. void HAL_JPEG_DataReadyCallback(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, uint32_t OutDataLength);
  436. /**
  437. * @}
  438. */
  439. /** @addtogroup JPEG_Exported_Functions_Group5
  440. * @{
  441. */
  442. /* JPEG IRQ handler management ******************************************************/
  443. void HAL_JPEG_IRQHandler(JPEG_HandleTypeDef *hjpeg);
  444. /**
  445. * @}
  446. */
  447. /** @addtogroup JPEG_Exported_Functions_Group6
  448. * @{
  449. */
  450. /* Peripheral State and Error functions ************************************************/
  451. HAL_JPEG_STATETypeDef HAL_JPEG_GetState(JPEG_HandleTypeDef *hjpeg);
  452. uint32_t HAL_JPEG_GetError(JPEG_HandleTypeDef *hjpeg);
  453. /**
  454. * @}
  455. */
  456. /**
  457. * @}
  458. */
  459. /* Private types -------------------------------------------------------------*/
  460. /** @defgroup JPEG_Private_Types JPEG Private Types
  461. * @{
  462. */
  463. /**
  464. * @}
  465. */
  466. /* Private defines -----------------------------------------------------------*/
  467. /** @defgroup JPEG_Private_Defines JPEG Private Defines
  468. * @{
  469. */
  470. /**
  471. * @}
  472. */
  473. /* Private variables ---------------------------------------------------------*/
  474. /** @defgroup JPEG_Private_Variables JPEG Private Variables
  475. * @{
  476. */
  477. /**
  478. * @}
  479. */
  480. /* Private constants ---------------------------------------------------------*/
  481. /** @defgroup JPEG_Private_Constants JPEG Private Constants
  482. * @{
  483. */
  484. /**
  485. * @}
  486. */
  487. /* Private macros ------------------------------------------------------------*/
  488. /** @defgroup JPEG_Private_Macros JPEG Private Macros
  489. * @{
  490. */
  491. #define IS_JPEG_CHROMASUBSAMPLING(SUBSAMPLING) (((SUBSAMPLING) == JPEG_444_SUBSAMPLING) || \
  492. ((SUBSAMPLING) == JPEG_420_SUBSAMPLING) || \
  493. ((SUBSAMPLING) == JPEG_422_SUBSAMPLING))
  494. #define IS_JPEG_IMAGE_QUALITY(NUMBER) (((NUMBER) >= JPEG_IMAGE_QUALITY_MIN) && ((NUMBER) <= JPEG_IMAGE_QUALITY_MAX))
  495. #define IS_JPEG_COLORSPACE(COLORSPACE) (((COLORSPACE) == JPEG_GRAYSCALE_COLORSPACE) || \
  496. ((COLORSPACE) == JPEG_YCBCR_COLORSPACE) || \
  497. ((COLORSPACE) == JPEG_CMYK_COLORSPACE))
  498. #define IS_JPEG_PAUSE_RESUME_STATE(VALUE) (((VALUE) == JPEG_PAUSE_RESUME_INPUT) || \
  499. ((VALUE) == JPEG_PAUSE_RESUME_OUTPUT)|| \
  500. ((VALUE) == JPEG_PAUSE_RESUME_INPUT_OUTPUT))
  501. /**
  502. * @}
  503. */
  504. /* Private functions prototypes ----------------------------------------------*/
  505. /** @defgroup JPEG_Private_Functions_Prototypes JPEG Private Functions Prototypes
  506. * @{
  507. */
  508. /**
  509. * @}
  510. */
  511. /* Private functions ---------------------------------------------------------*/
  512. /** @defgroup JPEG_Private_Functions JPEG Private Functions
  513. * @{
  514. */
  515. /**
  516. * @}
  517. */
  518. /**
  519. * @}
  520. */
  521. /**
  522. * @}
  523. */
  524. #endif /* JPEG */
  525. #ifdef __cplusplus
  526. }
  527. #endif
  528. #endif /* STM32H7xx_HAL_JPEG_H */
  529. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/