57.1 初学者重要提示
  由于硬件JPEG解码后输出的图像格式是YCbCr，所以本章对YCbCr进行了重点介绍。
  测试STM32H7硬件JPEG解码800*480图片性能，全部通过SDRAM缓存数据，解码10ms，显示9ms。
  JPEG涉及到的知识点还是比较多的，如果想深入了解JPEG的话，可以看本章2.6小节给的参考资料。
! G' P( f0 l+ W9 R( X  本章JPEG相关概念的介绍参考了wiki百科和百度百科。
5 G! G9 i. Q, c* d" x3 @57.2 硬件JPEG基础知识
对于STM32H7的硬件JPEG了解到以下几点即可：
0 f- r0 O& h6 V! T/ p2 o  支持JPEG解码和编码。
  对每个像素数据进行编解码只需一个时钟周期。
  支持RGB、 YCbCr、YCMK和BW（灰度）图像色彩模型。
  编解码时每图像分量8位深度。
! ?" c& G+ W9 H% g7 p+ q" F2 E57.2.1 JPEG硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速地了解JPEG的基本功能，然后再看手册了解细节。框图如下所示：
  i0 e6 \: c* E" k

通过这个框图，我们可以得到如下信息：

6 `" M! t7 `; P+ |5 x7 v  JPEG硬件外设支持编码和解码
并且对于输入数据和输出数据都有FIFO支持。
, {  Z3 x+ I3 _2 c9 V. C3 d! o! J
' H& R4 B% w; ^6 r% `  I6 [  jpeg_hclk
为JPEG内核和寄存器提供时钟。
' N3 r+ x  A8 U0 P$ c
  jpeg_it
JPEG全局中断输出。

8 X& A  _$ Y/ I: ^! N' y  jpeg_ift_trg
- z1 e* B5 c" \4 H: v6 {JPEG输入FIFO阈值信号，可触发MDMA。

  jpeg_ifnf_trg
" ^, t) V* H$ W- m6 [+ e7 eJPEG输入FIFO未满信号，可触发MDMA。
+ h/ U5 V6 p: ]3 y
* v0 Z0 l1 [6 M( f, N6 |  jpeg_oft_trg
( P/ m: x+ z$ g! gJPEG输出FIFO阀值信号，可触发MDMA。

  jpeg_ofne_trg
JPEG输出FIFO非空信号，可触发MDMA。

  jpeg_oec_trg
JPEG转换结束信号，可触发MDMA。
3 B. e. @% J; {
57.2.2 YCbCr颜色格式
（注，硬件JPEG解码后输出的图像格式是YCbCr，所以有必要了解下）
" M3 w  B8 t/ c' c( L; ]) q% V0 h
1 w  K6 O) L' e( x: ^4 Z7 \( V正如几何上用坐标空间来描述坐标集，而色彩空间用数学方式来描述颜色集。常见的3种色彩模型是RGB，CMYK和YUV。
8 b( E6 e8 ]# Z3 C  u0 I* E" v
YCbCr是YUV经过缩放和修改的翻版，只是在表示方法上不同。其中Y是指亮度分量，Cb指蓝色色度分量，而Cr指红色色度分量。人眼对视频的Y分量更敏感，因此通过对色度分量进行子采样来减少色度分量后，人眼察觉不到的图像质量的变化。
* ?* Z3 ~: U8 C; a
在YUV 家族中，YCbCr 是在计算机系统中应用最多的成员，其应用领域广泛，JPEG、MPEG均采用此格式。一般人们所讲的YUV大多是指YCbCr。
2 V! w. ]% l+ ?& B
57.2.3 YCbCr采样格式
YCbCr有许多取样格式，如YCbCr 4:4:4，YCbCr 4:2:2，YCbCr 4:1:1 和YCbCr 4:2:0。

  4:2:0
表示每4个像素有4个亮度分量，2个色度分量 (YYYYCbCr），仅采样奇数扫描线，是便携式视频设备（MPEG-4）以及电视会议（H.263）最常用格式。

  4:2:2
表示每4个像素有4个亮度分量，4个色度分量（YYYYCbCrCbCr），是DVD、数字电视、HDTV以及其它消费类视频设备的最常用格式。

  4:4:4
表示全像素点阵(YYYYCbCrCbCrCbCrCbCr），用于高质量视频应用、演播室以及专业视频产品。
+ \4 ]4 w2 \3 ]+ t9 {, R2 t) w$ ~$ H

具体的采样方式如下图所示，以8个像素为一个单元进行采样：

* p% |7 P  x+ H: L2 K
# U* J2 \$ Q4 f5 Z! y* a

' @% t% K' p, S8 E# D5 |+ |5 C( Q6 J2 f
/ Q! U0 U" F& ^0 S: v7 j由上面的截图可以了解到：

/ U4 }- Z% j4 ^, o4:4:4表示Y通道，Cb+Cr通道全部采样。

; o4 \# M" K" F2 _4:2:2表示Y通道全部采样，而Cb+Cr通道两个像素为一组，统一采用第1个颜色值。
; [# G: H5 f6 T, V! O+ m7 D7 p
4:2:0表示Y通道全部采样，而Cb+Cr通道四个像素为一组，统一采用第1个颜色值。

" I  V2 q, {. d) X% p% Z- u  a下面是整体效果，方便大家更好的理解：

  X8 F2 v# f1 ~& |6 X$ q

5 I. s) ]5 M0 I; ^# h57.2.4 YCbCr的优势
# H# ]' E0 X6 B0 q8 [& VRGB信号作为存储和传输的效率不高，因为它们具有大量冗余信息。而使用YCbCr可以丢弃一些信息以减少带宽，因为人的肉眼对视频的Y分量更敏感，因此通过对色度分量进行子采样来减少色度分量后，肉眼察觉不到的图像质量的变化。了解这种人为缺点，NTSC和PAL等标准大大降低了色度通道的带宽。
; a' i/ t6 O0 R- m! C
57.2.5 YCbCr和RGB互转
) r8 k6 L& A6 P0 K9 \% j为了方便大家更好的了解YCbCr和RGB图像的实际效果，特此搜集整理了两个截图（来自WIKI百科）。下面是图像转YCBCR的效果：四个图，从上到下依次是原始图像，Y通道，Cb通道和Cr通道。
1 E% l0 l7 G! @7 a0 f

+ _7 U0 L! O3 g. {0 B. _& Q/ P1 R下面是一幅图像分别以R，G，B通道和Y，CB，CR通道的方式展示：
$ s1 @+ B! ^' z! N) k$ v) ?- z
6 O( P. c0 o) H, J8 e

$ Y8 g0 F; N; V
57.2.6 JPEG编解码知识
5 n8 Y/ Q* ?3 f3 p4 J) N0 FJPEG涉及到的知识点比较多，这里有之前整理的20多个专题知识点，大家有兴趣可以了解下。
# y/ Z. ^+ o4 j0 T/ N4 i
* y  _7 ^  I$ q; K' z, m5 W0 g57.3 硬件JPEG的HAL库用法
JPEG的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置时钟，并根据需要配置NVIC、中断和MDMA。下面我们逐一展开为大家做个说明。
9 y7 h0 {5 [. M4 X  }
57.3.1 JPEG寄存器结构体JPEG_TypeDef
6 q! C% ~8 i2 x" j! SJPEG相关的寄存器是通过HAL库中的结构体JPEG_TypeDef定义的，在stm32h743xx.h中可以找到它们的具体定义：
; B1 @7 P; L% k( Z2 l- H; c$ `

1. typedef struct
   4 d# I/ L% b6 [3 Z; J6 C" @
2. {
   
3.   __IO uint32_t CONFR0;         
   
4.   __IO uint32_t CONFR1;         
   6 F6 b6 y4 K1 L! v" v8 a, z
5.   __IO uint32_t CONFR2;        
   0 v& [. t6 F1 c! U
6.   __IO uint32_t CONFR3;        
     ^% X3 o0 p' i+ T. S$ y' A$ A7 Y
7.   __IO uint32_t CONFR4;         
   # m8 {1 ~* H2 u  J7 ~* P
8.   __IO uint32_t CONFR5;      
   & B  J2 O8 d2 p: _  M
9.   __IO uint32_t CONFR6;      
   
10.   __IO uint32_t CONFR7;        
    % g  ]: Q2 A2 ?+ R# V/ X0 Y% M
11.   uint32_t  Reserved20[4];      
    # G8 I5 S. ]1 b4 D- l; D
12.   __IO uint32_t CR;            
    
13.   __IO uint32_t SR;            
    
14.   __IO uint32_t CFR;            
    * j8 a  }( V# I0 P. U. _
15.   uint32_t  Reserved3c;        
    , r+ Z, H% D5 o# a) g
16.   __IO uint32_t DIR;         
    
17.   __IO uint32_t DOR;            
    
18.   uint32_t  Reserved48[2];      
    ; A% m* w. w0 J# k! @  G
19.   __IO uint32_t QMEM0[16];     
    7 D; |4 [) T! Z  c! ?  V$ @
20.   __IO uint32_t QMEM1[16];      
    5 Z6 Z& }* t! |
21.   __IO uint32_t QMEM2[16];      
    8 s# n% t% b: G* g
22.   __IO uint32_t QMEM3[16];      
    
23.   __IO uint32_t HUFFMIN[16];   
    $ V- ^$ T4 Z* y  }5 a8 i
24.   __IO uint32_t HUFFBASE[32];   
    0 j. Y, m+ u0 f; T" P7 o1 h
25.   __IO uint32_t HUFFSYMB[84];   
    , ^0 Q' u. w$ N% {
26.   __IO uint32_t DHTMEM[103];   
    
27.   uint32_t  Reserved4FC;      
    
28.   __IO uint32_t HUFFENC_AC0[88];
    & X! P2 c- t) j8 V
29.   __IO uint32_t HUFFENC_AC1[88];
      l& _- _1 J. \8 y* D4 L7 o
30.   __IO uint32_t HUFFENC_DC0[8];  
    " {# c& l3 ]- H; g9 h1 m- w
31.   __IO uint32_t HUFFENC_DC1[8];
    9 I  d" v( a2 l
32. } JPEG_TypeDef;
    

复制代码

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

. o6 b3 C- z/ ~/ S
2 \7 [  `: k: t
! O. C# x8 ^9 L$ ^下面我们再看JPEG的定义，在stm32h743xx.h文件。
# J4 |  l8 N; y- o2 \0 s' S
. N! e' X* \) M8 \

1. #define PERIPH_BASE           ((uint32_t)0x40000000)
   
2. #define D1_AHB1PERIPH_BASE    (PERIPH_BASE + 0x12000000)
   ' y1 a# ^+ w! c% u2 m) ?  y
3. #define JPEG                  ((JPEG_TypeDef *) JPGDEC_BASE)
   
4. #define JPGDEC_BASE           (D1_AHB1PERIPH_BASE + 0x3000) <----- 展开这个宏，(JPEG_TypeDef *) 0x52003000

复制代码

5 F- T% S' r5 I. v: C
8 H' B- {- K5 o+ {1 i
3 J( e: Y; k; ^, P( D我们访问JPEG的CR寄存器可以采用这种形式：JPEG->CR = 0。
" I% j( k& c- I: F: b
3 U* f7 h5 P5 s. ^4 l57.3.2 JPEG的编解码参数结构体JPEG_ConfTypeDef
: g# b! l  T' G! e7 v' }; r此结构体用于JPEG的编解码参数，具体定义如下：

1. typedef struct
   
2. {
   
3.   uint8_t  ColorSpace;               
   
4.   uint8_t  ChromaSubsampling;        
   / s1 c0 A/ h# K9 y; o
5.   uint32_t ImageHeight;              
   0 v' j' `( C4 [$ w7 Q1 e
6.   uint32_t ImageWidth;            
   8 u; T! J3 \/ G- y' W* T
7.   uint8_t  ImageQuality;               
   " G, L) _3 k3 {. I) ?: {
8. }JPEG_ConfTypeDef;

复制代码

3 A0 i4 i( F2 P" U- l9 N  p下面将这几个参数逐一为大家做个说明：
, ]1 g' n. e4 k& X, ]( l6 b  |- z5 |
  uint8_t  ColorSpace
此参数用于设置输出数据流中的量化表，具体支持的参数如下：
. O0 {; Y" }4 i2 q, S% {$ V5 x
. O1 T0 b9 ]! v, ~+ K* s

1. #define JPEG_GRAYSCALE_COLORSPACE     ((uint32_t)0x00000000U)    /* 灰度（1 个量化表）*/
   
2. #define JPEG_YCBCR_COLORSPACE         JPEG_CONFR1_COLORSPACE_0   /* YUV（2 个量化表） */
   
3. #define JPEG_CMYK_COLORSPACE          JPEG_CONFR1_COLORSPACE     /* CMYK（4 个量化表）*/

复制代码

  uint8_t  ChromaSubsampling
此参数用于色度子采样，具体支持的参数如下：

. d2 n+ ^- @) Z( p$ k  g4 N1 G

1. #define JPEG_444_SUBSAMPLING     ((uint32_t)0x00000000U)   /* 4:4:4 */
   
2. #define JPEG_420_SUBSAMPLING     ((uint32_t)0x00000001U)   /* 4:2:0 */
   
3. #define JPEG_422_SUBSAMPLING     ((uint32_t)0x00000002U)   /* 4:2:2 */

复制代码

; z8 I1 g: n* G/ u; \0 p  uint32_t  ImageHeight
此参数用于图像高度。

) g% {: y) N7 C  uint32_t ImageWidth
8 p& p$ w  v, Z. f! J此参数用于图像宽度。

7 J2 y3 k5 v1 o3 N, V  uint8_t  ImageQuality
此参数用于图像质量，参数范围1 – 100，1最差，100最好。

57.3.3 JPEG结构体句柄JPEG_HandleTypeDef
HAL库在JPEG_TypeDef， JPEG_ConfTypeDef的基础上封装了一个结构体JPEG_HandleTypeDef，定义如下：
4 @; P- V; m5 g0 o) ?5 @( f) t( ^. N2 X

1. typedef struct
   + h$ C$ j7 h" |- j
2. {
   
3.   JPEG_TypeDef             *Instance;        
   0 }' n6 ^6 o' [* |9 }- N5 x
4.   JPEG_ConfTypeDef         Conf;            
   
5.   uint8_t                  *pJpegInBuffPtr;
   ( G$ p. Z  b3 F) @
6.   uint8_t                  *pJpegOutBuffPtr;
   ' @' d% ~$ \( u
7.   __IO uint32_t            JpegInCount;      
   
8.   __IO uint32_t            JpegOutCount;     
   / m' B3 @; B: P5 t5 e1 `0 ]- i
9.   uint32_t                 InDataLength;     
   
10.   uint32_t                 OutDataLength;     
      F9 F6 p5 [9 c9 T, c
11.   MDMA_HandleTypeDef        *hdmain;         
    ' S" {& m' }0 G  j2 A4 ?( Y
12.   MDMA_HandleTypeDef        *hdmaout;        
    
13.   uint8_t                  CustomQuanTable;
    
14.   uint8_t                  *QuantTable0;   
    
15.   uint8_t                  *QuantTable1;   
    
16.   uint8_t                  *QuantTable2;   
    
17.   uint8_t                  *QuantTable3;         
    , _2 I9 j: m8 X; ^1 w# K$ }
18.   HAL_LockTypeDef          Lock;            
    8 m! R0 g9 z# g/ a& W
19.   __IO  HAL_JPEG_STATETypeDef State;         
    1 j1 F, D0 Y) E6 V- }% e1 U2 c7 b. v
20.   __IO  uint32_t           ErrorCode;      
    . x6 Y+ j; ?+ C: _. w) U+ T* W, U
21.   __IO uint32_t Context;                    
    2 D) Z0 y* O4 L, V; Q
22. }JPEG_HandleTypeDef;

复制代码

下面将这几个参数逐一做个说明。

% Z# c4 x& t& ?8 K; \+ O/ R  JPEG_TypeDef   *Instance
这个参数是寄存器的例化，方便操作寄存器，详见本章3.1小节。

  JPEG_ConfTypeDef   Conf
这个参数是用户接触较多的，用于JPEG的编解码参数，详见本章3.2小节。
4 i/ y  i/ H- e/ m6 y
' }* R# N7 F" Q# X- _  uint8_t       *pJpegInBuffPtr
JPEG编解码输入缓冲地址

% x2 J' _; ^" g/ ^  uint8_t       *pJpegOutBuffPtr
JPEG编解码输出缓冲地址
; X; d; d% o* z0 @! s
% h4 @1 ^/ X- t* M9 _" o* y  __IO uint32_t   JpegInCount
JPEG内部输入计数。
: R2 y* K/ E  V/ h
3 M+ I# h3 \. _$ t  s  __IO uint32_t   JpegOutCount
JPEG内部输出计数。

  uint32_t        InDataLength
JPEG输入缓冲区长度，单位字节
& \3 o% h: m0 d* \$ d8 z8 \  ?
2 J" B1 y5 n+ V7 h" w3 Q' A, x  uint32_t          OutDataLength
JPEG输出缓冲区长度，单位字节。
4 m$ c- P7 C+ x3 p1 I. I% k' D
/ B# C+ C: Y, U8 E2 R; ]& }( X  MDMA_HandleTypeDef        *hdmain
  MDMA_HandleTypeDef        *hdmaout
MDMA句柄结构体指针变量，用于关联JPEG句柄，方便调用。

  uint8_t       CustomQuanTable
# N3 ~2 X$ Q& X  M: O如果此参数设置为1，将使用用户设置的量化表。

: [: [  K$ D& d  uint8_t      *QuantTable0;   
. p5 A' I+ U" R* D* U: U  uint8_t      *QuantTable1;     
  uint8_t      *QuantTable2;   
  uint8_t      *QuantTable3;
指定量化表地址。   

4 u1 l9 V8 t* c; X% f  HAL_LockTypeDef          Lock           
/ T, {9 P. h, @, b* q" n& J3 Z  __IO  HAL_JPEG_STATETypeDef State           
  __IO  uint32_t           ErrorCode      
# z5 `# S" t% o! _- [这三个变量主要供函数内部使用。Lock用于设置锁状态，State用于设置JPEG状态，而ErrorCode用于配置代码错误。

; c/ U9 k; |: o% N: t8 Z4 P  __IO uint32_t Context
. E2 z5 g; q) ]8 TJPEG上下文。

3 @! e% q* A% Y4 H; r) P# r* F) Y57.3.4 JPEG初始化流程总结
使用方法由HAL库提供：
7 w* ~: ?3 @- s4 z6 G9 l1 l5 D
  第1步：调用函数HAL_JPEG_Init进行初始化，但这个函数不需要初始化参数。
$ M' C$ E; w) U* C! Q
3 D' ]8 b) F3 I如果是JPEG编码，可以通过函数HAL_JPEG_ConfigEncoding设置JPEG图像的质量参数，质量越高，生成的JPEG文件越大、
1 H( A" }) U7 u; x
  第2步：调用编解码函数

  查询式编解码函数
HAL_JPEG_Encode

HAL_JPEG_Decode

  中断方式
. q6 Q$ u/ t# E; i9 {: ^HAL_JPEG_Encode_IT

HAL_JPEG_Decode_IT
1 M: b0 [2 z0 a8 W8 Q4 V. U0 b
  DMA方式
5 l- P" p! C; G+ r6 uHAL_JPEG_Encode_DMA
6 y: O, Z% D2 x3 M" h" d+ \2 @
) d  M* J+ b/ ~9 D. FHAL_JPEG_Decode_DMA

/ n' d! j5 s& N. \+ |' x# n) n3 y  第4步：如果用户之前的数据已经处理完毕，需要插入新数据，会调用函数HAL_JPEG_GetDataCallback

（1）如果新的数据已经准备好，需要调用函数HAL_JPEG_ConfigInputBuffer。如果新的数据没有准备好，需要等待插入新数据时，可以调用函数HAL_JPEG_Pause（参数XferSelection被设置为JPEG_PAUSE_RESUME_INPUT），待数据准备好后，可以调用HAL_JPEG_ConfigInputBuffer设置新的输入缓冲和大小，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。

如果编解码的数据已经处理完毕，可以调用函数HAL_JPEG_ConfigInputBuffer设置InDataLength参数为0（此函数是在回调函数HAL_JPEG_GetDataCallback里面被调用的）。
" e0 h9 k. H8 E  j2 G: L（2）函数HAL_JPEG_ConfigInputBuffer/HAL_JPEG_Pause/HAL_JPEG_Resume的工作机制允许应用程序以块为单位提供输入数据。如果新的数据块未准备好，可以调用函数HAL_JPEG_Pause暂停输入，待数据准备好后，可以调用HAL_JPEG_ConfigInputBuffer设置新的输入缓冲和大小，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。
4 z. F9 |$ W5 z: D4 L0 j# p（3）新的数据块准备好后，可以在回调函数HAL_JPEG_GetDataCallback外面调用HAL_JPEG_ConfigInputBuffer 和 HAL_JPEG_Resume，但是为了保持数据一致性问题，务必在回调函数HAL_JPEG_GetDataCallback里面调用HAL_JPEG_Resume。
  第5步：输出缓冲区填充了给定大小的数据后，会调用回调函数HAL_JPEG_DataReadyCallback
( u, _5 Q) }3 h2 V. D; W- ]（1）如果有数据空间存储新数据块，需要调用函数HAL_JPEG_ConfigOutputBuffer配置新存储位置。如果没有数据空间存储新数据块，需要等待有数据空间可用时，可以调用函数HAL_JPEG_Pause（参数XferSelection被设置为JPEG_PAUSE_RESUME_INPUT），待有数据空间可用时，可以调用HAL_JPEG_ConfigOutputBuffe设置新的输出缓冲，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。
（2）函数HAL_JPEG_ConfigOutputBuffe/HAL_JPEG_Pause/HAL_JPEG_Resume的工作机制允许应用程序以块为单位接收数据。当接收到数据块时，应用程序可以暂停JPEG输出来处理这些数据，比如解码时YCbCr转RGB或者编码时数据存储。
（3）新的数据空间准备好后，可以在回调函数HAL_JPEG_DataReadyCallback外面调用HAL_JPEG_ConfigOutputBuffer和 HAL_JPEG_Resume，但是为了保持数据一致性问题，务必在回调函数HAL_JPEG_DataReadyCallback里面调用HAL_JPEG_Resume。
  第6步：其它相关函数
  JPEG解码时，如果解码成功，会调用回调函数HAL_JPEG_InfoReadyCallback。
/ c% x- ^" A  K1 O: n  JPEG编码操作结束后会调用回调函数HAL_JPEG_EncodeCpltCallback。
0 ^" k2 o8 f9 Y' G- x( E% ?9 s, {  JPEG解码操作结束后，会调用回调函数HAL_JPEG_DecodeCpltCallback。
  操作过程中出现错误，会调用回调函数HAL_JPEG_ErrorCallback，用户可以调用函数HAL_JPEG_GetError获取错误类型。
6 }1 t8 g+ J/ F; `; f  HAL JPEG默认使用的是ISO/IEC 10918-1规格量化表，如果要修改，可以调用函数HAL_JPEG_SetUserQuantTables实现。
  通过函数HAL_JPEG_GetState可以获取JPEG状态。
; `" r. n7 A1 |1 k. S- K: {: H57.4 源文件stm32h7xx_hal_jpeg.c
这里把我们把如下几个常用到的函数做个说明：
8 @3 n/ C: y6 U1 g  HAL_JPEG_Init
. `  ]0 W( ^# `  HAL_JPEG_GetInfo
  HAL_JPEG_Decode_DMA
  HAL_JPEG_ConfigInputBuffer
! M% M0 {4 r4 C( P* T" @' q  HAL_JPEG_ConfigOutputBuffer
57.4.1 函数HAL_JPEG_Init
7 t) I& j' y! d6 i9 O6 r7 a; [( [函数原型：
9 G3 P4 a3 Z& @, A# K- k. S
5 O. a+ [0 \% ?: Y" T

1. HAL_StatusTypeDef HAL_JPEG_Init(JPEG_HandleTypeDef *hjpeg)
   
2. {
   
3.   uint32_t acLum_huffmanTableAddr = (uint32_t)(&JPEG_ACLUM_HuffTable);
   
4.   uint32_t dcLum_huffmanTableAddr = (uint32_t)(&JPEG_DCLUM_HuffTable);
   
5.   uint32_t acChrom_huffmanTableAddr = (uint32_t)(&JPEG_ACCHROM_HuffTable);
   
6.   uint32_t dcChrom_huffmanTableAddr = (uint32_t)(&JPEG_DCCHROM_HuffTable);
   
7. 
   
8.   /* 检测句柄是否有效 */
   
9.   if(hjpeg == NULL)
   
10.   {
    . R* K! V6 S+ [" u  }
11.     return HAL_ERROR;
    # E8 p( A9 I. ^3 t+ o0 v. J9 F7 c/ _# d0 f
12.   }
    
13. 
    . q3 o2 K9 s: l( I
14.   if(hjpeg->State == HAL_JPEG_STATE_RESET)
    
15.   {
    
16.     hjpeg->Lock = HAL_UNLOCKED;
    
17. 
    / ^  `8 n  H2 C7 r0 W) s
18.      /* 初始化GPIO，NVIC等 */
    4 q" R) `% c5 Z! A0 F
19.     HAL_JPEG_MspInit(hjpeg);
    3 r2 K# O# K( P0 W5 [
20.   }
    7 [* O( v* g( M" A. g
21. 
    4 Z, g0 G9 E; K
22.   /* 设置JPEG状态 */
    
23.   hjpeg->State = HAL_JPEG_STATE_BUSY;
    : ?4 n2 M+ z/ s" b
24. 
    
25.   /* 使能JPEG  */
    
26.   __HAL_JPEG_ENABLE(hjpeg);
    
27. 
    5 a3 f% @# n! Q! @3 @1 g) E& S
28.   /* 关闭JPEG编解码处理 */
    4 \% n9 D& i5 m9 z- T
29.   hjpeg->Instance->CONFR0 &=  ~JPEG_CONFR0_START;
    2 v7 @, h$ |5 H: p
30. 
    
31.   /* 关闭JPEG所有中断 */
    
32.   __HAL_JPEG_DISABLE_IT(hjpeg,JPEG_INTERRUPT_MASK);
    
33. 
    
34.   /* 清空输入输入FIFO缓冲 */
    
35.   hjpeg->Instance->CR |= JPEG_CR_IFF;
    
36.   hjpeg->Instance->CR |= JPEG_CR_OFF;  
      b( _6 `) O8 K: c4 o4 [/ e. O# X
37. 
    
38.   /* 清除所有标志 */
    
39.   __HAL_JPEG_CLEAR_FLAG(hjpeg,JPEG_FLAG_ALL);
    
40. 
    
41.   /* 初始化默认的量化表 */
    
42.   hjpeg->QuantTable0 = (uint8_t *)((uint32_t)JPEG_LUM_QuantTable);
    ; Y+ i* I( c$ u; R  j
43.   hjpeg->QuantTable1 = (uint8_t *)((uint32_t)JPEG_CHROM_QuantTable);
    
44.   hjpeg->QuantTable2 = NULL;
    ) k  Z: w% k& {% A
45.   hjpeg->QuantTable3 = NULL;
    7 h* y7 Y: ?; Y& O* A
46. 
    " |+ ~3 }( g; Z/ I+ R4 ^. S0 b! b# T8 H
47.   /* 初始化默认的霍夫曼表 */
    
48.   if(JPEG_Set_HuffEnc_Mem(hjpeg, (JPEG_ACHuffTableTypeDef *)acLum_huffmanTableAddr, (JPEG_DCHuffTableTypeDef *)dcLum_huffmanTableAddr, (JPEG_ACHuffTableTypeDef *)acChrom_huffmanTableAddr, (JPEG_DCHuffTableTypeDef *)dcChrom_huffmanTableAddr) != HAL_OK)
    : c, v; o6 `! Z  y# _! I. @) y
49.   {
    3 u' n$ D5 V# L* i4 Y9 H% \3 }1 Q( K
50.     hjpeg->ErrorCode = HAL_JPEG_ERROR_HUFF_TABLE;
    
51. 
    
52.     return HAL_ERROR;
    
53.   }
    $ d, N6 d1 T# t: A( s  V9 J8 S
54. 
    3 h/ ^4 e" k% c) v
55.   /* 使能文件头处理 */
    
56.   hjpeg->Instance->CONFR1 |= JPEG_CONFR1_HDR;
    
57. 
    # A/ ?6 _) f2 z& d' y6 s
58.   /* 复位JPEG输入输出计数 */
    4 T  q2 j4 F  ]4 K
59.   hjpeg->JpegInCount = 0;
    
60.   hjpeg->JpegOutCount = 0;
    
61. 
    
62.   /* 设置JPEG就绪 */
    
63.   hjpeg->State = HAL_JPEG_STATE_READY;
    4 g1 ~' V5 u' p2 d0 M
64. 
    2 N- {6 i, ^2 j: ~/ U4 V
65.   /* 设置无错误 Reset the JPEG ErrorCode */
    - T$ c; L1 n1 _; u" h4 i
66.   hjpeg->ErrorCode = HAL_JPEG_ERROR_NONE;
    
67. 
    
68.   /* 清除上下文 */
    
69.   hjpeg->Context = 0;
    2 K4 j( r9 O4 d, d! C( E, f3 O- r
70. 
    
71.   /* 返回HAL_OK */
    8 g) Z" [- K( N; F; n
72.   return HAL_OK;
    
73. }

复制代码

# _1 s( Z6 h$ x6 O7 Y
, o3 P$ H, P. s. b, ^5 J( y函数描述：
& V% K/ h7 X0 W. j2 T
此函数用于初始化JPEG。
* M3 S$ s/ ?0 Z: u+ l7 ~  Y
函数参数：

- l$ Y" e" H# J8 k2 G( r2 _% |  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
& M: s" F& i4 @6 Z5 Z0 |4 _  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
3 k! P* q/ i% k: d
函数HAL_JPEG_MspInit用于初始化JPEG的底层时钟、NVIC等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
$ z& W% u2 n8 w$ v. p5 J: u如果形参hjpeg的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量JPEG_HandleTypeDef JpegHandle。
( u4 r; F) P; L0 L/ h6 n  r9 k对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_JPEG_STATE_RESET  = 0x00U。

' K( q( F" d. b# e解决办法有三
  W( k. p, q7 U9 G! a
' M6 h0 s& B, ]5 S- x) d方法1：用户自己初始JPEG底层。

9 p5 K) k4 p- I* X0 H. T' U方法2：定义JPEG_HandleTypeDef JpegHandle为全局变量。
5 }, ]& G; B) c
方法3：下面的方法

1. if(HAL_JPEG_DeInit(&JpegHandle) != HAL_OK)
   , n  m/ w4 o; ]9 T" f. j+ v
2. {
   6 }5 [3 b8 J  ]. [% M: r3 I
3.     Error_Handler();
   
4. }  
     W4 T3 x1 T, R$ s/ i- T
5. if(HAL_JPEG_Init(&Dma2dHandle) != HAL_OK)
   6 `$ q/ z% p7 w/ y& w% n; h$ g
6. {
   
7.     Error_Handler();
   + S* F4 E1 E6 t$ Z
8. }

复制代码

使用举例：

1. JPEG_HandleTypeDef    JPEG_Handle;
   
2. JPEG_Handle.Instance = JPEG;
   ( ~  J% K& A& R5 |4 f( Y
3. HAL_JPEG_Init(&JPEG_Handle);

复制代码

57.4.2 函数HAL_JPEG_GetInfo
2 O) a7 v9 d$ F( ]) j$ |函数原型：
% \. ]3 R( `+ i7 e( h
5 o7 A: I  T; ~

1. HAL_StatusTypeDef HAL_JPEG_GetInfo(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo)
   4 |7 \" N' Z3 H, H# ^
2. {
   ! l6 A1 _% W5 {' b3 j
3.   uint32_t yblockNb, cBblockNb, cRblockNb;
   
4. 
   
5.   /* 检测句柄是否有效 */
   
6.   if((hjpeg == NULL) || (pInfo == NULL))
   
7.   {
   - Y% N# \. B' E( n
8.     return HAL_ERROR;
   
9.   }
   , y' h2 o- K5 V; P: I7 R
10. 
    
11.   /* 读取配置参数 */
    
12.   if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF_1)
    ; `" f: |, _' j' M  W5 N
13.   {
    & v: Q5 j) B5 {; o. T
14.     pInfo->ColorSpace = JPEG_YCBCR_COLORSPACE;   
    # ]; B" ?9 ^. u: a# v, P
15.   }   
    
16.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == 0)
    
17.   {
      F, M. h/ [8 i- M) ]
18.     pInfo->ColorSpace = JPEG_GRAYSCALE_COLORSPACE;
    6 Z- |9 M# M, ^3 Z% K
19.   }
    6 i! [' ^$ t5 J* Y0 ?6 Q
20.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF)
    
21.   {
    ! K# h4 E" f5 ]
22.     pInfo->ColorSpace = JPEG_CMYK_COLORSPACE;   
    
23.   }
    
24. 
    
25.   pInfo->ImageHeight = (hjpeg->Instance->CONFR1 & 0xFFFF0000U) >> 16;
    - @8 f0 v. L  h& N
26.   pInfo->ImageWidth  = (hjpeg->Instance->CONFR3 & 0xFFFF0000U) >> 16;
    8 A/ ^: h, a5 F& D
27. 
    
28.   if((pInfo->ColorSpace == JPEG_YCBCR_COLORSPACE) || (pInfo->ColorSpace == JPEG_CMYK_COLORSPACE))
    6 f7 G; k/ \3 @% \- {% h
29.   {
    # u+ _$ P: U1 }, @* y5 [( m
30.     yblockNb  = (hjpeg->Instance->CONFR4 & JPEG_CONFR4_NB) >> 4;
    2 y! q: k0 g1 X0 G( ?+ Z
31.     cBblockNb = (hjpeg->Instance->CONFR5 & JPEG_CONFR5_NB) >> 4;
    
32.     cRblockNb = (hjpeg->Instance->CONFR6 & JPEG_CONFR6_NB) >> 4;
    ' T6 Q$ m, W, \1 s4 h" {
33. 
    
34.     if((yblockNb == 1) && (cBblockNb == 0) && (cRblockNb == 0))
    
35.     {
    
36.       pInfo->ChromaSubsampling = JPEG_422_SUBSAMPLING; /*16x8 block*/
    
37.     }
    
38.     else if((yblockNb == 0) && (cBblockNb == 0) && (cRblockNb == 0))
    ' @" K* x1 I8 K: K' j
39.     {
    
40.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    ( g7 |  X' Q) P
41.     }
    3 T8 h0 F7 F& m4 u1 k  ^  t, S
42.     else if((yblockNb == 3) && (cBblockNb == 0) && (cRblockNb == 0))
    
43.     {
    
44.       pInfo->ChromaSubsampling = JPEG_420_SUBSAMPLING;
    : _. ^4 r2 Y, I- e) M
45.     }
    
46.     else /* 默认是 4:4:4*/
    : U  `2 K1 G3 f: z
47.     {
    
48.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    ) D; d# O( D$ A! s0 s+ w0 R
49.     }
    
50.   }
    
51.   else
    / k- t0 r+ f1 }8 G8 k# e% |
52.   {
    
53.     pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    ) ^9 f* J) ?5 b! X7 `
54.   }
    ' ?1 z; r. s0 _% l! M; @) t1 k
55. 
    
56.   pInfo->ImageQuality = JPEG_GetQuality(hjpeg);
    
57. 
    ; p6 K. V; |; c" Y$ L* w
58.   /* 返回HAL_OK */
    
59.   return HAL_OK;
    : r( ?4 \$ ?! Q8 V5 ]' T
60. }

复制代码

6 G: L1 {- t) S" V- b函数描述：

# i" n2 |2 i; f# `& r/ J此函数主要用于解码JPEG时获取相关图像信息，比如图像质量，图像长宽等。
) \) [% g1 H* `+ A8 M) ~2 H# j
函数参数：
2 v% F0 l% T9 V
, m  f5 s7 _4 K8 H6 Q  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是JPEG_ConfTypeDef类型结构体指针变量，用于获取JPEG的配置信息，结构体变量成员的详细介绍看本章3.2小
+ N8 |. v+ ~* V2 @3 Y  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
使用举例：
( l* l  A: T( L0 r, @
) Y9 Y8 P- K# i+ e9 r  V" F

1. JPEG_HandleTypeDef    JPEG_Handle;
   & l; U6 U# i1 t& P, d. F
2. JPEG_ConfTypeDef      JPEG_Info;
   2 d4 m8 t! ?% u2 y5 u
3. 
   " U, O3 r+ O) G6 d& q: o$ _
4. HAL_JPEG_GetInfo(&JPEG_Handle, &JPEG_Info);  

复制代码

2 n! W# g9 P+ m( }) Z+ a( [
57.4.3 函数HAL_JPEG_Decode_DMA
* z$ J- R% ~: ^- M% d函数原型：

1. HAL_StatusTypeDef  HAL_JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg ,uint8_t *pDataIn ,uint32_t InDataLength ,uint8_t *pDataOutMCU ,uint32_t OutDataLength)
   
2. {
   1 a3 U' m) W0 L0 M3 |8 J- c
3.   /* 检测参数 */
   , e3 X& ~& @( Y7 j: q0 n7 l  E& A
4.   assert_param((InDataLength >= 4));
   3 D  S3 d3 N5 k: g9 p# o
5.   assert_param((OutDataLength >= 4));
   
6. 
   & C) S/ g5 Z% ^/ e+ j
7.   /* 检测参数 */
   : h+ J' W4 `% @: @. _5 |
8.   if((hjpeg == NULL) || (pDataIn == NULL) || (pDataOutMCU == NULL))
   0 z* V4 s4 ^5 E, F- q3 {
9.   {
   - H2 \' x: V9 V) `) J9 X, h; Z+ d8 s
10.     return HAL_ERROR;
    % ?' B" ?4 Y* e! {- x
11.   }
    8 V% E+ d# q. E  ^0 a' }
12. 
    6 K, D9 s! ~3 C- d
13.   /* 上锁 */
    8 _) N1 U2 K& |  A- N
14.   __HAL_LOCK(hjpeg);
    ! o. h) N- r0 \& i. t, u5 W" }
15. 
    . T# z4 p* z1 z  T: k# T+ m8 s/ {
16.   if(hjpeg->State == HAL_JPEG_STATE_READY)
      h3 y8 g- A% c0 C
17.   {
    2 e+ Q( k* F1 I8 w$ T* {4 P1 y
18.     /* 设置JPEG忙 */
    
19.     hjpeg->State = HAL_JPEG_STATE_BUSY_DECODING;
    * l3 H' S+ X& u: l
20. 
    - B9 v( W& l1 {9 q( L4 G
21.     /* 设置JPEG上下文，工作在DMA界面状态 */
    4 V+ f+ g& Q6 O, T3 \- A5 {
22.     hjpeg->Context &= ~(JPEG_CONTEXT_OPERATION_MASK | JPEG_CONTEXT_METHOD_MASK);
    
23.     hjpeg->Context |= (JPEG_CONTEXT_DECODE | JPEG_CONTEXT_DMA);         
    
24. 
    
25.     /* 设置输入输出缓冲地址和大小 */
    
26.     hjpeg->pJpegInBuffPtr = pDataIn;
    1 T- j6 A& P8 ^' ?/ k5 F
27.     hjpeg->pJpegOutBuffPtr = pDataOutMCU;
    - k- T* v- O! W) X
28.     hjpeg->InDataLength = InDataLength;
    ; k) e! Z$ }. y. ~( L" E
29.     hjpeg->OutDataLength = OutDataLength;
    $ C- R! ?+ s9 \; P( w
30. 
    3 ?7 D8 O, i% i! x9 X6 D5 J
31.     /* 复位输入输出缓冲计数 */
    : `, T% U. o7 L
32.     hjpeg->JpegInCount = 0;   
    3 e! v: Q/ A5 {; Z, g' p/ k* V+ t4 w
33.     hjpeg->JpegOutCount = 0;   
    
34. 
    ' v% i" j+ I: F, Y
35.     /* 初始化解码处理 */
    
36.     JPEG_Init_Process(hjpeg);
    
37. 
    . h! R# S4 v8 y& p/ b
38.     /* 启动JPEG解码处理，使用DMA方式 */
    0 K* e: L) D% j
39.     JPEG_DMA_StartProcess(hjpeg);
    
40. 
    
41.   }
    9 ?, L% E6 N8 G/ p% ]! s9 @( ]
42.   else
    % Q3 t  k  e2 e# h6 O& Q, x- I
43.   {
    5 Q$ i! E0 a; o. a! m) q3 y
44.     /* 解锁 */
      i( K# d5 X9 p7 L; q) T
45.     __HAL_UNLOCK(hjpeg);
    
46. 
      h5 ^9 i9 v* d* V. f0 ~
47.     return HAL_BUSY;
    
48.   }
    4 v+ f* s5 Q8 j( y
49. 
    % {- ^4 h; T* Z7 J( t
50.   /* 返回HAL_OK */
    9 \9 Q! w' [1 \  i0 x, l+ V0 z/ P9 I
51.   return HAL_OK;
    
52. }

复制代码

函数描述：

此函数用于启动JPEG的DMA方式解码。

* v, \% I* v9 G+ `1 B( A4 N8 k函数参数：

  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
9 d5 R! l5 A6 ]" N- K) w  第2个参数是输入数据缓冲地址。
; y3 w1 Q9 U7 ?  |  R4 d  第3个参数输入数据大小，单位字节。
, `# m/ z3 {, W# x' X  第4个参数是输出缓冲地址。
* n! u* L+ @+ ^% y9 t  第5个参数是输出缓冲大小，单位字节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
" {& u- d8 f! V* V% G  l2 u使用举例：
$ w% x, n! k' X, p/ v
: W2 r/ {+ o$ ]9 N+ l8 r" U  W

1. /*
   " q+ F! }6 g/ R  U3 t0 o" @5 \7 J
2. *********************************************************************************************************
   ! A7 l2 c. K  H
3. *    函 数 名: JPEG_Decode_DMA
   6 X9 m  {" w3 M5 s
4. *    功能说明: JPEG解码
   
5. *    形    参: hjpeg               JPEG_HandleTypeDef句柄指针
   
6. *             FrameSourceAddress  数据地址
   
7. *             FrameSize           数据大小
   
8. *             DestAddress         目的数据地址
   
9. *    返 回 值: HAL_ERROR表示配置失败，HAL_OK表示配置成功
   5 Y0 S- s+ ~0 L$ r: K
10. *             HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出
    
11. *********************************************************************************************************
    1 O, B, E& o; ]! a  b" m# M4 m8 I
12. */
    
13. uint32_t JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg, uint32_t FrameSourceAddress ,uint32_t FrameSize, uint32_t DestAddress)
    ( g8 O7 l; o4 e! o: Q# r/ Y6 R
14. {
    " g' X3 D+ ]' B7 l( ~
15.     JPEGSourceAddress =  FrameSourceAddress ;
    2 P" N$ \: o/ }3 K8 X. O, f
16.     FrameBufferAddress = DestAddress;
    
17.     Input_frameIndex = 0;
    
18.     Input_frameSize = FrameSize;
    & G0 Q. Q  z( f3 V) O/ S
19. 
    
20.     /* 设置标志，0表示开始解码，1表示解码完成 */
    
21.     Jpeg_HWDecodingEnd = 0;
    ; ?8 c/ u( \9 P; k1 B8 K( L1 u- ?3 X
22. 
    * U/ Z4 Y8 {3 p* {$ e3 k/ }
23.     /* 启动JPEG解码 */
    ) `% R5 \& s4 k1 D7 K
24.     HAL_JPEG_Decode_DMA(hjpeg ,(uint8_t *)JPEGSourceAddress ,CHUNK_SIZE_IN ,
    $ e0 X9 P. l9 Q
25. (uint8_t *)FrameBufferAddress ,CHUNK_SIZE_OUT);
    & Y3 e4 \% r; _, C/ ]: t
26. 
    
27.     return HAL_OK;
    ' [& s7 I3 l- N+ }% w9 h5 z6 w. Q
28. }
    

复制代码

57.4.4 函数HAL_JPEG_ConfigInputBuffer
! M+ U% O5 m8 [1 y$ j. X9 B函数原型：
( B- w2 t8 r* u! g$ G7 R

1. void HAL_JPEG_ConfigInputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewInputBuffer, uint32_t InDataLength)
   $ z* [) N3 _- |+ s6 E* @
2. {
     r; b) c* U; ?; u8 O/ G6 g
3.   hjpeg->pJpegInBuffPtr =  pNewInputBuffer;
   5 K( V6 a1 c% l& F
4.   hjpeg->InDataLength = InDataLength;
   
5. }
   : l- a, L4 s/ T4 r

复制代码

函数描述：
% X) c  n% \' Y- I/ @
( c& G( o9 M% g, r" c0 H7 t; V此函数用于配置编解码输入缓冲地址和数据大小。

函数参数：

; t8 e. J' O0 }+ L) Q3 v  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是输入缓冲地址。
* V3 u$ j5 P1 F# O& F2 l  第3个参数是输入缓冲大小，单位字节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
, j' p: k. K- W: C6 D" W: N; z使用举例：
& w' u7 e$ x) q' z) |) z; C
; F9 H- u% p/ j

1. /*
   
2. *********************************************************************************************************
   ) W& Q. U" {3 b2 t+ q2 y$ K7 l
3. *    函 数 名: HAL_JPEG_GetDataCallback
   
4. *    功能说明: JPEG回调函数，用于从输入地址获取新数据继续解码
   $ x" }$ X; _9 x: N2 ?, M
5. *    形    参: hjpeg          JPEG_HandleTypeDef 句柄指针
   
6. *             NbDecodedData  上一轮已经解码的数据大小，单位字节  
     C( M% E' ^, f8 M; }* I5 o/ [
7. *    返 回 值: 无
   % A% S8 a; u5 q% I: ?6 u/ n# y
8. *********************************************************************************************************
   
9. */
   8 f, U2 w6 _& G6 Q) S7 _+ s$ S4 c
10. void HAL_JPEG_GetDataCallback(JPEG_HandleTypeDef *hjpeg, uint32_t NbDecodedData)
    
11. {
    
12.     uint32_t inDataLength;
    8 P  \' g" c3 `2 P+ s$ A. I$ b
13. 
    
14.     /* 更新已经解码的数据大小 */
    
15.     Input_frameIndex += NbDecodedData;
    
16. 
    / S& m8 ]. n9 v# f  G' I
17.     /* 如果当前已经解码的数据小于总文件大小，继续解码 */
    
18.     if( Input_frameIndex < Input_frameSize)
    
19.     {
    
20.         /* 更新解码数据位置 */
    # P/ D( C3 r4 q- [0 e; p
21.         JPEGSourceAddress = JPEGSourceAddress + NbDecodedData;
    ! z; M+ \$ u3 T0 m
22. 
    0 U- e2 ^1 N/ L5 Q$ k
23.         /* 更新下一轮要解码的数据大小 */
    
24.         if((Input_frameSize - Input_frameIndex) >= CHUNK_SIZE_IN)
    ( Y2 P* `$ |4 j; o/ D/ y8 K" t! E
25.         {
    
26.             inDataLength = CHUNK_SIZE_IN;
    % K" I3 o! n. m* I0 A
27.         }
      Z$ T# G$ }# e+ _2 v/ ^6 Y
28.         else
    
29.         {
    
30.             inDataLength = Input_frameSize - Input_frameIndex;
    2 \! m! P! ~6 Y9 \0 v
31.         }   
    0 |' H/ L! M3 M/ F, x% M
32.     }
    
33.     else
    $ M+ g5 r  f, d
34.     {
    
35.         inDataLength = 0;
    
36.     }
    7 @, ^$ e% J$ X2 @
37. 
    & N5 b% I3 `9 n7 F
38.     /* 更新输入缓冲 */
    
39.     HAL_JPEG_ConfigInputBuffer(hjpeg,(uint8_t *)JPEGSourceAddress, inDataLength);   
    
40. }
    

复制代码

57.4.5 函数HAL_JPEG_ConfigOutputBuffer
+ I( t1 o* [( B; o, S函数原型：
; K. C" I* V. u$ O, Y( u1 N8 F

1. void HAL_JPEG_ConfigOutputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewOutputBuffer, uint32_t OutDataLength)
   $ p2 l" Q* j, Q1 g
2. {
   
3.   hjpeg->pJpegOutBuffPtr = pNewOutputBuffer;
   
4.   hjpeg->OutDataLength = OutDataLength;  
   
5. }

复制代码

' x# D9 ]1 A" Y& n  u函数描述：
. `) n4 B- m8 F) L4 }+ m
1 [- ~4 E* L- C% i* Y* s此函数用于配置编解码输出缓冲地址和数据大小。

函数参数：
! k1 _3 U; \. R, n# R, W- A1 Z
  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
+ B8 C% H! h& t/ T8 e! i$ X4 D  第2个参数是输出缓冲地址。
7 y4 t% x; @8 s6 K7 O  第3个参数是输出缓冲大小，单位字节。
1 k& V' u9 G, }% _( ^; q' R  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
( s/ v% Y8 J+ K% n! e3 S使用举例：
4 L0 t1 D$ p: E2 e7 L
" b# f+ y# ]; s9 Y- `8 B  N

1. /*
   7 U6 |8 X6 |4 p( z3 O& E
2. *********************************************************************************************************
   6 w4 Q1 S# C4 U3 ?
3. *    函 数 名: HAL_JPEG_DataReadyCallback
   
4. *    功能说明: JPEG回调函数，用于输出缓冲地址更新
   
5. *    形    参: hjpeg         JPEG_HandleTypeDef 句柄指针
   
6. *             pDataOut      输出数据缓冲
   ( N6 A. B; x0 b) A- D0 P1 o, n. y
7. *             OutDataLength 输出数据大小，单位字节
   : m; z$ A. ?' z7 W
8. *    返 回 值: 无
   + t2 h% N3 x  f3 L
9. *********************************************************************************************************
   
10. */
    7 X& T. J6 X. D9 k- x* j8 c
11. void HAL_JPEG_DataReadyCallback (JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, uint32_t OutDataLength)
    
12. {
    ) h) c7 ~( v( y) v$ o/ w3 v# d" [+ r: K
13.     /* 更新JPEG输出地址 */  
    : ~/ c8 q, V0 C; w: r
14.     FrameBufferAddress += OutDataLength;
    
15. 
    
16.     HAL_JPEG_ConfigOutputBuffer(hjpeg, (uint8_t *)FrameBufferAddress, CHUNK_SIZE_OUT);
    # q; m& J) U5 [' m  {
17. }
    / x' R) X) s( m5 B# ]9 M0 }4 `) d8 Q

复制代码

0 X. G$ O4 b7 z3 n0 x) h
& q6 I# V2 f9 R( ~57.5 总结
2 S& v2 b" {% S- n' q; u2 p本章节就为大家讲解这么多，JPEG功能用到的地方还是比较多的，建议熟练使用。

" t; r4 m+ i$ f- Z* A1 r
! f' _  D: d! u& w( W1 Y% n

: x" \7 W% L+ W% O3 v+ D- ~3 g8 N9 k4 N