lib/main/STM32F7/Drivers/STM32F7xx_HAL_Driver/Inc/stm32f7xx_hal_jpeg.h

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f7xx_hal_jpeg.h
   4   * @author  MCD Application Team
   5   * @version V1.2.2
   6   * @date    14-April-2017
   7   * @brief   Header file of JPEG HAL module.
   8   ******************************************************************************
   9   * @attention
  10   *
  11   * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
  12   *
  13   * Redistribution and use in source and binary forms, with or without modification,
  14   * are permitted provided that the following conditions are met:
  15   *   1. Redistributions of source code must retain the above copyright notice,
  16   *      this list of conditions and the following disclaimer.
  17   *   2. Redistributions in binary form must reproduce the above copyright notice,
  18   *      this list of conditions and the following disclaimer in the documentation
  19   *      and/or other materials provided with the distribution.
  20   *   3. Neither the name of STMicroelectronics nor the names of its contributors
  21   *      may be used to endorse or promote products derived from this software
  22   *      without specific prior written permission.
  23   *
  24   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  27   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  28   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  32   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  33   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34   *
  35   ******************************************************************************
  36   */
  37
  38 /* Define to prevent recursive inclusion -------------------------------------*/
  39 #ifndef __STM32F7xx_HAL_JPEG_H
  40 #define __STM32F7xx_HAL_JPEG_H
  41
  42 #ifdef __cplusplus
  43  extern "C" {
  44 #endif
  45 #if defined (STM32F767xx) || defined (STM32F769xx) || defined (STM32F777xx) || defined (STM32F779xx)
  46 /* Includes ------------------------------------------------------------------*/
  47 #include "stm32f7xx_hal_def.h"
  48
  49 /** @addtogroup STM32F7xx_HAL_Driver
  50   * @{
  51   */
  52
  53 /** @addtogroup JPEG
  54   * @{
  55   */
  56
  57 /* Exported types ------------------------------------------------------------*/
  58 /** @defgroup JPEG_Exported_Types JPEG Exported Types
  59   * @{
  60   */
  61
  62 /** @defgroup JPEG_Configuration_Structure_definition JPEG Configuration for encoding Structure definition
  63   * @brief  JPEG encoding configuration Structure definition
  64   * @{
  65   */
  66 typedef struct
  67 {
  68   uint8_t  ColorSpace;                /*!< Image Color space : gray-scale, YCBCR, RGB or CMYK
  69                                            This parameter can be a value of @ref JPEG_ColorSpace_Type */
  70
  71   uint8_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
  72                                            This parameter can be a value of @ref JPEG_ChromaSubsampling_Type */
  73
  74   uint32_t ImageHeight;               /*!< Image height : number of lines */
  75
  76   uint32_t ImageWidth;                /*!< Image width : number of pixels per line */
  77
  78   uint8_t  ImageQuality;               /*!< Quality of the JPEG encoding : from 1 to 100 */
  79
  80 }JPEG_ConfTypeDef;
  81 /**
  82   * @}
  83   */
  84
  85 /** @defgroup HAL_JPEG_state_structure_definition HAL JPEG state structure definition
  86   * @brief  HAL JPEG State structure definition
  87   * @{
  88   */
  89 typedef enum
  90 {
  91   HAL_JPEG_STATE_RESET              = 0x00U,  /*!< JPEG not yet initialized or disabled  */
  92   HAL_JPEG_STATE_READY              = 0x01U,  /*!< JPEG initialized and ready for use    */
  93   HAL_JPEG_STATE_BUSY               = 0x02U,  /*!< JPEG internal processing is ongoing   */
  94   HAL_JPEG_STATE_BUSY_ENCODING      = 0x03U,  /*!< JPEG encoding processing is ongoing   */
  95   HAL_JPEG_STATE_BUSY_DECODING      = 0x04U,  /*!< JPEG decoding processing is ongoing   */
  96   HAL_JPEG_STATE_TIMEOUT            = 0x05U,  /*!< JPEG timeout state                    */
  97   HAL_JPEG_STATE_ERROR              = 0x06U   /*!< JPEG error state                      */
  98 }HAL_JPEG_STATETypeDef;
  99
 100 /**
 101   * @}
 102   */
 103
 104
 105 /** @defgroup JPEG_handle_Structure_definition JPEG handle Structure definition
 106   * @brief  JPEG handle Structure definition
 107   * @{
 108   */
 109 typedef struct
 110 {
 111   JPEG_TypeDef             *Instance;        /*!< JPEG peripheral register base address */
 112
 113   JPEG_ConfTypeDef         Conf;             /*!< Current JPEG encoding/decoding parameters */
 114
 115   uint8_t                  *pJpegInBuffPtr;  /*!< Pointer to JPEG processing (encoding, decoding,...) input buffer */
 116
 117   uint8_t                  *pJpegOutBuffPtr; /*!< Pointer to JPEG processing (encoding, decoding,...) output buffer */
 118
 119   __IO uint32_t            JpegInCount;      /*!< Internal Counter of input data */
 120
 121   __IO uint32_t            JpegOutCount;     /*!< Internal Counter of output data */
 122
 123   uint32_t                 InDataLength;     /*!< Input Buffer Length in Bytes */
 124
 125   uint32_t                 OutDataLength;    /*!< Output Buffer Length in Bytes */
 126
 127   DMA_HandleTypeDef        *hdmain;          /*!< JPEG In DMA handle parameters */
 128
 129   DMA_HandleTypeDef        *hdmaout;         /*!< JPEG Out DMA handle parameters */
 130
 131   uint8_t                  CustomQuanTable;  /*!< If set to 1 specify that user customized quantization tables are used */
 132
 133   uint8_t                  *QuantTable0;     /*!< Basic Quantization Table for component 0 */
 134
 135   uint8_t                  *QuantTable1;     /*!< Basic Quantization Table for component 1 */
 136
 137   uint8_t                  *QuantTable2;     /*!< Basic Quantization Table for component 2 */
 138
 139   uint8_t                  *QuantTable3;     /*!< Basic Quantization Table for component 3 */
 140
 141   HAL_LockTypeDef          Lock;             /*!< JPEG locking object */
 142
 143   __IO  HAL_JPEG_STATETypeDef State;         /*!< JPEG peripheral state */
 144
 145   __IO  uint32_t           ErrorCode;        /*!< JPEG Error code */
 146
 147   __IO uint32_t Context;                     /*!< JPEG Internal context */
 148
 149 }JPEG_HandleTypeDef;
 150
 151 /**
 152   * @}
 153   */
 154
 155 /**
 156   * @}
 157   */
 158
 159 /* Exported constants --------------------------------------------------------*/
 160
 161 /** @defgroup JPEG_Exported_Constants JPEG Exported Constants
 162   * @{
 163   */
 164
 165 /** @defgroup JPEG_Error_Code_definition JPEG Error Code definition
 166   * @brief  JPEG Error Code definition
 167   * @{
 168   */
 169
 170 #define  HAL_JPEG_ERROR_NONE        ((uint32_t)0x00000000U)    /*!< No error             */
 171 #define  HAL_JPEG_ERROR_HUFF_TABLE  ((uint32_t)0x00000001U)    /*!< HUffman Table programming error */
 172 #define  HAL_JPEG_ERROR_QUANT_TABLE ((uint32_t)0x00000002U)    /*!< Quantization Table programming error */
 173 #define  HAL_JPEG_ERROR_DMA         ((uint32_t)0x00000004U)    /*!< DMA transfer error   */
 174 #define  HAL_JPEG_ERROR_TIMEOUT     ((uint32_t)0x00000008U)    /*!< Timeout error        */
 175
 176 /**
 177   * @}
 178   */
 179
 180 /** @defgroup JPEG_Quantization_Table_Size JPEG Quantization Table Size
 181   * @brief  JPEG Quantization Table Size
 182   * @{
 183   */
 184 #define JPEG_QUANT_TABLE_SIZE  ((uint32_t)64U)
 185 /**
 186   * @}
 187   */
 188
 189
 190 /** @defgroup JPEG_ColorSpace_Type JPEG ColorSpace
 191   * @brief  JPEG Color Space
 192   * @{
 193   */
 194 #define JPEG_GRAYSCALE_COLORSPACE     ((uint32_t)0x00000000U)
 195 #define JPEG_YCBCR_COLORSPACE         JPEG_CONFR1_COLORSPACE_0
 196 #define JPEG_CMYK_COLORSPACE          JPEG_CONFR1_COLORSPACE
 197
 198
 199 /**
 200   * @}
 201   */
 202
 203
 204 /** @defgroup JPEG_ChromaSubsampling_Type JPEG Chrominance Sampling
 205   * @brief  JPEG Chrominance Sampling
 206   * @{
 207   */
 208 #define JPEG_444_SUBSAMPLING     ((uint32_t)0x00000000U)   /*!< Chroma Subsampling 4:4:4 */
 209 #define JPEG_420_SUBSAMPLING     ((uint32_t)0x00000001U)   /*!< Chroma Subsampling 4:2:0 */
 210 #define JPEG_422_SUBSAMPLING     ((uint32_t)0x00000002U)   /*!< Chroma Subsampling 4:2:2 */
 211
 212 /**
 213   * @}
 214   */
 215
 216 /** @defgroup JPEG_ImageQuality JPEG Image Quality
 217   * @brief  JPEG Min and Max Image Quality
 218   * @{
 219   */
 220 #define JPEG_IMAGE_QUALITY_MIN     ((uint32_t)1U)     /*!< Minimum JPEG quality */
 221 #define JPEG_IMAGE_QUALITY_MAX     ((uint32_t)100U)   /*!< Maximum JPEG quality */
 222
 223 /**
 224   * @}
 225   */
 226
 227 /** @defgroup JPEG_Interrupt_configuration_definition JPEG Interrupt configuration definition
 228   * @brief JPEG Interrupt definition
 229   * @{
 230   */
 231 #define JPEG_IT_IFT     ((uint32_t)JPEG_CR_IFTIE)   /*!< Input FIFO Threshold Interrupt */
 232 #define JPEG_IT_IFNF    ((uint32_t)JPEG_CR_IFNFIE)  /*!< Input FIFO Not Full Interrupt */
 233 #define JPEG_IT_OFT     ((uint32_t)JPEG_CR_OFTIE)   /*!< Output FIFO Threshold Interrupt */
 234 #define JPEG_IT_OFNE    ((uint32_t)JPEG_CR_OFTIE)   /*!< Output FIFO Not Empty Interrupt */
 235 #define JPEG_IT_EOC     ((uint32_t)JPEG_CR_EOCIE)   /*!< End of Conversion Interrupt */
 236 #define JPEG_IT_HPD     ((uint32_t)JPEG_CR_HPDIE)   /*!< Header Parsing Done Interrupt */
 237 /**
 238   * @}
 239   */
 240
 241 /** @defgroup JPEG_Flag_definition JPEG Flag definition
 242   * @brief JPEG Flags definition
 243   * @{
 244   */
 245 #define JPEG_FLAG_IFTF     ((uint32_t)JPEG_SR_IFTF)   /*!< Input FIFO is not full and is bellow its threshold flag */
 246 #define JPEG_FLAG_IFNFF    ((uint32_t)JPEG_SR_IFNFF)  /*!< Input FIFO Not Full Flag, a data can be written */
 247 #define JPEG_FLAG_OFTF     ((uint32_t)JPEG_SR_OFTF)   /*!< Output FIFO is not empty and has reach its threshold */
 248 #define JPEG_FLAG_OFNEF    ((uint32_t)JPEG_SR_OFNEF)  /*!< Output FIFO is not empty, a data is available  */
 249 #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  */
 250 #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  */
 251 #define JPEG_FLAG_COF      ((uint32_t)JPEG_SR_COF)    /*!< JPEG Codec operation on going  flag*/
 252
 253 #define JPEG_FLAG_ALL      ((uint32_t)0x000000FEU)     /*!< JPEG Codec All previous flag*/
 254 /**
 255   * @}
 256   */
 257
 258 /** @defgroup JPEG_PROCESS_PAUSE_RESUME_definition JPEG Process Pause Resume definition
 259   * @brief JPEG process pause, resume definition
 260   * @{
 261   */
 262 #define JPEG_PAUSE_RESUME_INPUT          ((uint32_t)0x00000001U)     /*!< Pause/Resume Input FIFO Xfer*/
 263 #define JPEG_PAUSE_RESUME_OUTPUT         ((uint32_t)0x00000002U)     /*!< Pause/Resume Output FIFO Xfer*/
 264 #define JPEG_PAUSE_RESUME_INPUT_OUTPUT   ((uint32_t)0x00000003U)     /*!< Pause/Resume Input and Output FIFO Xfer*/
 265 /**
 266   * @}
 267   */
 268
 269 /**
 270   * @}
 271   */
 272 /* Exported macro ------------------------------------------------------------*/
 273
 274 /** @defgroup JPEG_Exported_Macros JPEG Exported Macros
 275   * @{
 276   */
 277
 278 /** @brief Reset JPEG handle state
 279   * @param  __HANDLE__: specifies the JPEG handle.
 280   * @retval None
 281   */
 282 #define __HAL_JPEG_RESET_HANDLE_STATE(__HANDLE__) ( (__HANDLE__)->State = HAL_JPEG_STATE_RESET)
 283
 284
 285 /**
 286   * @brief  Enable the JPEG peripheral.
 287   * @param  __HANDLE__: specifies the JPEG handle.
 288   * @retval None
 289   */
 290 #define __HAL_JPEG_ENABLE(__HANDLE__)  ((__HANDLE__)->Instance->CR |=  JPEG_CR_JCEN)
 291
 292 /**
 293   * @brief Disable the JPEG peripheral.
 294   * @param  __HANDLE__: specifies the JPEG handle.
 295   * @retval None
 296   */
 297 #define __HAL_JPEG_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR &=  ~JPEG_CR_JCEN)
 298
 299
 300 /**
 301   * @brief  Check the specified JPEG status flag.
 302   * @param  __HANDLE__: specifies the JPEG handle.
 303   * @param  __FLAG__ : specifies the flag to check
 304   *         This parameter can be one of the following values:
 305   *         @arg JPEG_FLAG_IFTF  : The input FIFO is not full and is bellow its threshold flag
 306   *         @arg JPEG_FLAG_IFNFF : The input FIFO Not Full Flag, a data can be written
 307   *         @arg JPEG_FLAG_OFTF  : The output FIFO is not empty and has reach its threshold
 308   *         @arg JPEG_FLAG_OFNEF : The output FIFO is not empty, a data is available
 309   *         @arg JPEG_FLAG_EOCF  : JPEG Codec core has finished the encoding or the decoding process
 310   *                                and than last data has been sent to the output FIFO
 311   *         @arg JPEG_FLAG_HPDF  : JPEG Codec has finished the parsing of the headers
 312   *                                and the internal registers have been updated
 313   *         @arg JPEG_FLAG_COF   : JPEG Codec operation on going  flag
 314   *
 315   * @retval : __HAL_JPEG_GET_FLAG : returns The new state of __FLAG__ (TRUE or FALSE)
 316   */
 317
 318 #define __HAL_JPEG_GET_FLAG(__HANDLE__,__FLAG__)  (((__HANDLE__)->Instance->SR & (__FLAG__)))
 319
 320 /**
 321   * @brief  Clear the specified JPEG status flag.
 322   * @param  __HANDLE__: specifies the JPEG handle.
 323   * @param  __FLAG__ : specifies the flag to clear
 324   *         This parameter can be one of the following values:
 325   *         @arg JPEG_FLAG_EOCF  : JPEG Codec core has finished the encoding or the decoding process
 326   *                                and than last data has been sent to the output FIFO
 327   *         @arg JPEG_FLAG_HPDF  : JPEG Codec has finished the parsing of the headers
 328   * @retval : None
 329   */
 330
 331 #define __HAL_JPEG_CLEAR_FLAG(__HANDLE__,__FLAG__)  (((__HANDLE__)->Instance->CFR |= ((__FLAG__) & (JPEG_FLAG_EOCF | JPEG_FLAG_HPDF))))
 332
 333
 334 /**
 335   * @brief  Enable Interrupt.
 336   * @param   __HANDLE__: specifies the JPEG handle.
 337   * @param  __INTERRUPT__ : specifies the interrupt to enable
 338   *         This parameter can be one of the following values:
 339   *         @arg JPEG_IT_IFT   : Input FIFO Threshold Interrupt
 340   *         @arg JPEG_IT_IFNF  : Input FIFO Not Full Interrupt
 341   *         @arg JPEG_IT_OFT   : Output FIFO Threshold Interrupt
 342   *         @arg JPEG_IT_OFNE  : Output FIFO Not empty Interrupt
 343   *         @arg JPEG_IT_EOC   : End of Conversion Interrupt
 344   *         @arg JPEG_IT_HPD   : Header Parsing Done Interrupt
 345   *
 346   * @retval : No retrun
 347   */
 348 #define __HAL_JPEG_ENABLE_IT(__HANDLE__,__INTERRUPT__)  ((__HANDLE__)->Instance->CR |= (__INTERRUPT__) )
 349
 350 /**
 351   * @brief  Disable Interrupt.
 352   * @param   __HANDLE__: specifies the JPEG handle.
 353   * @param  __INTERRUPT__ : specifies the interrupt to disable
 354   *         This parameter can be one of the following values:
 355   *         @arg JPEG_IT_IFT   : Input FIFO Threshold Interrupt
 356   *         @arg JPEG_IT_IFNF  : Input FIFO Not Full Interrupt
 357   *         @arg JPEG_IT_OFT   : Output FIFO Threshold Interrupt
 358   *         @arg JPEG_IT_OFNE  : Output FIFO Not empty Interrupt
 359   *         @arg JPEG_IT_EOC   : End of Conversion Interrupt
 360   *         @arg JPEG_IT_HPD   : Header Parsing Done Interrupt
 361   *
 362   * @note  : To disable an IT we must use MODIFY_REG macro to avoid writing "1" to the FIFO flush bits
 363   *          located in the same IT enable register (CR register).
 364   * @retval : No retrun
 365   */
 366 #define __HAL_JPEG_DISABLE_IT(__HANDLE__,__INTERRUPT__) MODIFY_REG((__HANDLE__)->Instance->CR, (__INTERRUPT__), 0)
 367
 368
 369 /**
 370   * @brief  Get Interrupt state.
 371   * @param   __HANDLE__: specifies the JPEG handle.
 372   * @param  __INTERRUPT__ : specifies the interrupt to check
 373   *         This parameter can be one of the following values:
 374   *         @arg JPEG_IT_IFT   : Input FIFO Threshold Interrupt
 375   *         @arg JPEG_IT_IFNF  : Input FIFO Not Full Interrupt
 376   *         @arg JPEG_IT_OFT   : Output FIFO Threshold Interrupt
 377   *         @arg JPEG_IT_OFNE  : Output FIFO Not empty Interrupt
 378   *         @arg JPEG_IT_EOC   : End of Conversion Interrupt
 379   *         @arg JPEG_IT_HPD   : Header Parsing Done Interrupt
 380   *
 381   * @retval : returns The new state of __INTERRUPT__ (Enabled or disabled)
 382   */
 383 #define __HAL_JPEG_GET_IT_SOURCE(__HANDLE__,__INTERRUPT__)     ((__HANDLE__)->Instance->CR & (__INTERRUPT__))
 384
 385 /**
 386   * @}
 387   */
 388
 389 /* Exported functions --------------------------------------------------------*/
 390 /** @addtogroup JPEG_Exported_Functions
 391   * @{
 392   */
 393
 394 /** @addtogroup JPEG_Exported_Functions_Group1
 395   * @{
 396   */
 397 /* Initialization/de-initialization functions  ********************************/
 398 HAL_StatusTypeDef HAL_JPEG_Init(JPEG_HandleTypeDef *hjpeg);
 399 HAL_StatusTypeDef HAL_JPEG_DeInit(JPEG_HandleTypeDef *hjpeg);
 400 void HAL_JPEG_MspInit(JPEG_HandleTypeDef *hjpeg);
 401 void HAL_JPEG_MspDeInit(JPEG_HandleTypeDef *hjpeg);
 402
 403 /**
 404   * @}
 405   */
 406
 407 /** @addtogroup JPEG_Exported_Functions_Group2
 408   * @{
 409   */
 410 /* Encoding/Decoding Configuration functions  ********************************/
 411 HAL_StatusTypeDef HAL_JPEG_ConfigEncoding(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pConf);
 412 HAL_StatusTypeDef HAL_JPEG_GetInfo(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo);
 413 HAL_StatusTypeDef HAL_JPEG_EnableHeaderParsing(JPEG_HandleTypeDef *hjpeg);
 414 HAL_StatusTypeDef HAL_JPEG_DisableHeaderParsing(JPEG_HandleTypeDef *hjpeg);
 415 HAL_StatusTypeDef HAL_JPEG_SetUserQuantTables(JPEG_HandleTypeDef *hjpeg, uint8_t *QTable0, uint8_t *QTable1, uint8_t *QTable2, uint8_t *QTable3);
 416
 417 /**
 418   * @}
 419   */
 420
 421 /** @addtogroup JPEG_Exported_Functions_Group3
 422   * @{
 423   */
 424 /* JPEG processing functions  **************************************/
 425 HAL_StatusTypeDef  HAL_JPEG_Encode(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength, uint8_t *pDataOut, uint32_t OutDataLength, uint32_t Timeout);
 426 HAL_StatusTypeDef  HAL_JPEG_Decode(JPEG_HandleTypeDef *hjpeg ,uint8_t *pDataIn ,uint32_t InDataLength ,uint8_t *pDataOutMCU ,uint32_t OutDataLength, uint32_t Timeout);
 427 HAL_StatusTypeDef  HAL_JPEG_Encode_IT(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength, uint8_t *pDataOut, uint32_t OutDataLength);
 428 HAL_StatusTypeDef  HAL_JPEG_Decode_IT(JPEG_HandleTypeDef *hjpeg ,uint8_t *pDataIn ,uint32_t InDataLength ,uint8_t *pDataOutMCU ,uint32_t OutDataLength);
 429 HAL_StatusTypeDef  HAL_JPEG_Encode_DMA(JPEG_HandleTypeDef *hjpeg, uint8_t *pDataInMCU, uint32_t InDataLength, uint8_t *pDataOut, uint32_t OutDataLength);
 430 HAL_StatusTypeDef  HAL_JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg ,uint8_t *pDataIn ,uint32_t InDataLength ,uint8_t *pDataOutMCU ,uint32_t OutDataLength);
 431 HAL_StatusTypeDef  HAL_JPEG_Pause(JPEG_HandleTypeDef *hjpeg, uint32_t XferSelection);
 432 HAL_StatusTypeDef  HAL_JPEG_Resume(JPEG_HandleTypeDef *hjpeg, uint32_t XferSelection);
 433 void HAL_JPEG_ConfigInputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewInputBuffer, uint32_t InDataLength);
 434 void HAL_JPEG_ConfigOutputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewOutputBuffer, uint32_t OutDataLength);
 435 HAL_StatusTypeDef HAL_JPEG_Abort(JPEG_HandleTypeDef *hjpeg);
 436
 437 /**
 438   * @}
 439   */
 440
 441 /** @addtogroup JPEG_Exported_Functions_Group4
 442   * @{
 443   */
 444 /* JPEG Decode/Encode callback functions  ********************************************************/
 445 void HAL_JPEG_InfoReadyCallback(JPEG_HandleTypeDef *hjpeg,JPEG_ConfTypeDef *pInfo);
 446 void HAL_JPEG_EncodeCpltCallback(JPEG_HandleTypeDef *hjpeg);
 447 void HAL_JPEG_DecodeCpltCallback(JPEG_HandleTypeDef *hjpeg);
 448 void HAL_JPEG_ErrorCallback(JPEG_HandleTypeDef *hjpeg);
 449 void HAL_JPEG_GetDataCallback(JPEG_HandleTypeDef *hjpeg, uint32_t NbDecodedData);
 450 void HAL_JPEG_DataReadyCallback (JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, uint32_t OutDataLength);
 451
 452 /**
 453   * @}
 454   */
 455
 456 /** @addtogroup JPEG_Exported_Functions_Group5
 457   * @{
 458   */
 459 /* JPEG IRQ handler management  ******************************************************/
 460 void HAL_JPEG_IRQHandler(JPEG_HandleTypeDef *hjpeg);
 461
 462 /**
 463   * @}
 464   */
 465
 466 /** @addtogroup JPEG_Exported_Functions_Group6
 467   * @{
 468   */
 469 /* Peripheral State and Error functions  ************************************************/
 470 HAL_JPEG_STATETypeDef  HAL_JPEG_GetState(JPEG_HandleTypeDef *hjpeg);
 471 uint32_t               HAL_JPEG_GetError(JPEG_HandleTypeDef *hjpeg);
 472
 473 /**
 474   * @}
 475   */
 476
 477 /**
 478   * @}
 479   */
 480
 481 /* Private types -------------------------------------------------------------*/
 482 /** @defgroup JPEG_Private_Types JPEG Private Types
 483   * @{
 484   */
 485
 486 /**
 487   * @}
 488   */
 489
 490 /* Private defines -----------------------------------------------------------*/
 491 /** @defgroup JPEG_Private_Defines JPEG Private Defines
 492   * @{
 493   */
 494
 495 /**
 496   * @}
 497   */
 498
 499 /* Private variables ---------------------------------------------------------*/
 500 /** @defgroup JPEG_Private_Variables JPEG Private Variables
 501   * @{
 502   */
 503
 504 /**
 505   * @}
 506   */
 507
 508 /* Private constants ---------------------------------------------------------*/
 509 /** @defgroup JPEG_Private_Constants JPEG Private Constants
 510   * @{
 511   */
 512
 513 /**
 514   * @}
 515   */
 516
 517 /* Private macros ------------------------------------------------------------*/
 518 /** @defgroup JPEG_Private_Macros JPEG Private Macros
 519   * @{
 520   */
 521
 522 /** @defgroup JPEG_IS_Definitions JPEG Private macros to check input parameters
 523   * @{
 524   */
 525
 526 #define IS_JPEG_CHROMASUBSAMPLING(SUBSAMPLING) (((SUBSAMPLING) == JPEG_444_SUBSAMPLING) || \
 527                                                 ((SUBSAMPLING) == JPEG_420_SUBSAMPLING) || \
 528                                                 ((SUBSAMPLING) == JPEG_422_SUBSAMPLING))
 529
 530 #define IS_JPEG_IMAGE_QUALITY(NUMBER) (((NUMBER) >= JPEG_IMAGE_QUALITY_MIN) && ((NUMBER) <= JPEG_IMAGE_QUALITY_MAX))
 531
 532 #define IS_JPEG_COLORSPACE(COLORSPACE) (((COLORSPACE) == JPEG_GRAYSCALE_COLORSPACE) || \
 533                                         ((COLORSPACE) == JPEG_YCBCR_COLORSPACE)     || \
 534                                         ((COLORSPACE) == JPEG_CMYK_COLORSPACE))
 535
 536 #define IS_JPEG_PAUSE_RESUME_STATE(VALUE) (((VALUE) == JPEG_PAUSE_RESUME_INPUT) || \
 537                                            ((VALUE) == JPEG_PAUSE_RESUME_OUTPUT)|| \
 538                                            ((VALUE) == JPEG_PAUSE_RESUME_INPUT_OUTPUT))
 539
 540 /**
 541   * @}
 542   */
 543
 544 /**
 545   * @}
 546   */
 547
 548 /* Private functions prototypes ----------------------------------------------*/
 549 /** @defgroup JPEG_Private_Functions_Prototypes JPEG Private Functions Prototypes
 550   * @{
 551   */
 552
 553 /**
 554   * @}
 555   */
 556
 557 /* Private functions ---------------------------------------------------------*/
 558 /** @defgroup JPEG_Private_Functions JPEG Private Functions
 559   * @{
 560   */
 561
 562 /**
 563   * @}
 564   */
 565
 566 /**
 567   * @}
 568   */
 569
 570 /**
 571   * @}
 572   */
 573
 574 #endif /* STM32F767xx ||  STM32F769xx ||  STM32F777xx ||  STM32F779xx */
 575 #ifdef __cplusplus
 576 }
 577 #endif
 578
 579 #endif /* __STM32F7xx_HAL_JPEG_H */
 580
 581 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/