57.1 初学者重要提示
  由于硬件JPEG解码后输出的图像格式是YCbCr，所以本章对YCbCr进行了重点介绍。
  测试STM32H7硬件JPEG解码800*480图片性能，全部通过SDRAM缓存数据，解码10ms，显示9ms。
  JPEG涉及到的知识点还是比较多的，如果想深入了解JPEG的话，可以看本章2.6小节给的参考资料。
  本章JPEG相关概念的介绍参考了wiki百科和百度百科。
% e; B) w: u; k8 _, ~- O& v57.2 硬件JPEG基础知识
对于STM32H7的硬件JPEG了解到以下几点即可：
# r; V# [# s# I; k' S
  支持JPEG解码和编码。
! z" n+ Q  o7 f! @* k- |  对每个像素数据进行编解码只需一个时钟周期。
; W. Y8 X7 i& Z- j$ `  支持RGB、 YCbCr、YCMK和BW（灰度）图像色彩模型。
  编解码时每图像分量8位深度。

57.2.1 JPEG硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速地了解JPEG的基本功能，然后再看手册了解细节。框图如下所示：
9 G9 J$ ^& S: p( M0 p) `
& U# h0 S8 L. ?$ }! c. n5 |! ~+ ^; `' l

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

9 e4 [( X9 q- y6 U/ l; u  JPEG硬件外设支持编码和解码
并且对于输入数据和输出数据都有FIFO支持。
2 C1 g" A; Z+ e5 x1 D. X! L1 n7 S. u
  jpeg_hclk
为JPEG内核和寄存器提供时钟。
) X# N, @& T% S8 I. n8 F
  jpeg_it
) c5 V1 G5 q& G4 s, [JPEG全局中断输出。
7 C  e* ~+ ?* [' P% }
  jpeg_ift_trg
# L: D* Y5 n8 z0 y* uJPEG输入FIFO阈值信号，可触发MDMA。

  jpeg_ifnf_trg
JPEG输入FIFO未满信号，可触发MDMA。
3 ]6 A& q8 ]! c0 g8 d
  jpeg_oft_trg
JPEG输出FIFO阀值信号，可触发MDMA。

  jpeg_ofne_trg
JPEG输出FIFO非空信号，可触发MDMA。
" b! W. g5 c+ T0 n" m1 p
9 w; B3 q( T4 T- h+ O1 T  jpeg_oec_trg
0 R' k/ C$ L3 C6 lJPEG转换结束信号，可触发MDMA。
9 s4 p7 _0 a; p0 [1 t$ H7 W
57.2.2 YCbCr颜色格式
（注，硬件JPEG解码后输出的图像格式是YCbCr，所以有必要了解下）
6 J9 w0 Z# [+ S* w# N7 j
正如几何上用坐标空间来描述坐标集，而色彩空间用数学方式来描述颜色集。常见的3种色彩模型是RGB，CMYK和YUV。

YCbCr是YUV经过缩放和修改的翻版，只是在表示方法上不同。其中Y是指亮度分量，Cb指蓝色色度分量，而Cr指红色色度分量。人眼对视频的Y分量更敏感，因此通过对色度分量进行子采样来减少色度分量后，人眼察觉不到的图像质量的变化。
7 x# u! }+ |* W# f* o: Z$ X, N
. @, J0 `# G+ U8 R  K在YUV 家族中，YCbCr 是在计算机系统中应用最多的成员，其应用领域广泛，JPEG、MPEG均采用此格式。一般人们所讲的YUV大多是指YCbCr。

57.2.3 YCbCr采样格式
YCbCr有许多取样格式，如YCbCr 4:4:4，YCbCr 4:2:2，YCbCr 4:1:1 和YCbCr 4:2:0。
  V1 Q- ?& I- q% m
& T* J' H' Q' Q- l$ e( d  4:2:0
# l" P! D) z& A# Y7 p' w( G表示每4个像素有4个亮度分量，2个色度分量 (YYYYCbCr），仅采样奇数扫描线，是便携式视频设备（MPEG-4）以及电视会议（H.263）最常用格式。
1 l+ X1 Z# L+ @$ x  z
1 \* w0 F" J% P( k) i8 h9 F  4:2:2
表示每4个像素有4个亮度分量，4个色度分量（YYYYCbCrCbCr），是DVD、数字电视、HDTV以及其它消费类视频设备的最常用格式。
4 G9 ^* U: Q  n9 b, I/ F$ e8 E) A
  4:4:4
( }  i% e+ f. F1 C, ^7 e% G表示全像素点阵(YYYYCbCrCbCrCbCrCbCr），用于高质量视频应用、演播室以及专业视频产品。
& ]! F: j5 X: F/ C4 I
具体的采样方式如下图所示，以8个像素为一个单元进行采样：
+ X7 s  r( ]' t. N& o# [3 O! _

9 o/ U0 B( m8 w
) W) w5 ?8 ~: G4 G  \# X% U由上面的截图可以了解到：
. @' f* \! ?9 l" o& J. f: X# Q
4:4:4表示Y通道，Cb+Cr通道全部采样。

' [4 ]8 h6 q- b* A# a7 l4:2:2表示Y通道全部采样，而Cb+Cr通道两个像素为一组，统一采用第1个颜色值。
2 `6 F! e" r) n$ H* |
7 D4 i- W1 y/ ?& Y; e* E4:2:0表示Y通道全部采样，而Cb+Cr通道四个像素为一组，统一采用第1个颜色值。
% k( i0 H! H6 K: g4 c# R9 K) W
下面是整体效果，方便大家更好的理解：

' x9 f- r; H0 j7 {7 y) G

1 Y4 A* m0 J# f  l/ q4 A+ @) e+ X, A57.2.4 YCbCr的优势
RGB信号作为存储和传输的效率不高，因为它们具有大量冗余信息。而使用YCbCr可以丢弃一些信息以减少带宽，因为人的肉眼对视频的Y分量更敏感，因此通过对色度分量进行子采样来减少色度分量后，肉眼察觉不到的图像质量的变化。了解这种人为缺点，NTSC和PAL等标准大大降低了色度通道的带宽。

57.2.5 YCbCr和RGB互转
" h0 ]. P4 `3 U为了方便大家更好的了解YCbCr和RGB图像的实际效果，特此搜集整理了两个截图（来自WIKI百科）。下面是图像转YCBCR的效果：四个图，从上到下依次是原始图像，Y通道，Cb通道和Cr通道。

$ P; T7 B: L* ]# D# Y' y% q2 I

+ p/ r. s$ q  L: k3 u+ Z
下面是一幅图像分别以R，G，B通道和Y，CB，CR通道的方式展示：
$ l( O2 h/ c- g+ A8 s1 d: ~) n8 Q

- ?7 ^5 [$ o' \( k: B- A7 F4 X+ ?
57.2.6 JPEG编解码知识
JPEG涉及到的知识点比较多，这里有之前整理的20多个专题知识点，大家有兴趣可以了解下（不了解也没有关系，不影响使用硬件JPEG外设）
& `1 i3 T  N8 B( W2 @, D
57.3 硬件JPEG的HAL库用法
JPEG的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置时钟，并根据需要配置NVIC、中断和MDMA。下面我们逐一展开为大家做个说明。
7 B, d1 W6 [7 z7 y( U0 q& k# }' x
1 [/ r% @' O! C$ d4 b  J( S57.3.1 JPEG寄存器结构体JPEG_TypeDef
JPEG相关的寄存器是通过HAL库中的结构体JPEG_TypeDef定义的，在stm32h743xx.h中可以找到它们的具体定义：

7 x7 Z' q5 u3 y1 }% f. N' U

1. typedef struct
   
2. {
   
3.   __IO uint32_t CONFR0;         
   7 Y: o6 e  j4 C2 n" r9 [+ d
4.   __IO uint32_t CONFR1;         
   4 }( ~5 Z" O1 R5 B' O
5.   __IO uint32_t CONFR2;        
   8 O' b- J$ }+ W% v, H' c
6.   __IO uint32_t CONFR3;        
   
7.   __IO uint32_t CONFR4;         
   1 L, s  D# w% y3 Z% [; G6 m
8.   __IO uint32_t CONFR5;      
   
9.   __IO uint32_t CONFR6;      
   
10.   __IO uint32_t CONFR7;        
    
11.   uint32_t  Reserved20[4];      
    . m: T5 A2 H5 Z; O) V- O% G# A
12.   __IO uint32_t CR;            
    3 n, P! b% E2 F4 w
13.   __IO uint32_t SR;            
    
14.   __IO uint32_t CFR;            
    . O& }& e; z+ k
15.   uint32_t  Reserved3c;        
    9 X- L4 r  y1 a) F- N1 D
16.   __IO uint32_t DIR;         
    
17.   __IO uint32_t DOR;            
    
18.   uint32_t  Reserved48[2];      
    0 d; M& T6 c& g0 F7 _5 e
19.   __IO uint32_t QMEM0[16];     
    
20.   __IO uint32_t QMEM1[16];      
    
21.   __IO uint32_t QMEM2[16];      
    & z$ E+ C- P  b$ u
22.   __IO uint32_t QMEM3[16];      
    
23.   __IO uint32_t HUFFMIN[16];   
    : I- e$ ]" v( t
24.   __IO uint32_t HUFFBASE[32];   
    5 F1 i/ _# }; n) y  h/ U3 A
25.   __IO uint32_t HUFFSYMB[84];   
    : [4 S  O8 g. C
26.   __IO uint32_t DHTMEM[103];   
    
27.   uint32_t  Reserved4FC;      
    
28.   __IO uint32_t HUFFENC_AC0[88];
    
29.   __IO uint32_t HUFFENC_AC1[88];
    
30.   __IO uint32_t HUFFENC_DC0[8];  
      F+ s8 S! N3 U1 y! }! r4 M
31.   __IO uint32_t HUFFENC_DC1[8];
    . n, t3 b/ t" }  R
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 */

复制代码

) r) {3 ]" e* q' p; p下面我们再看JPEG的定义，在stm32h743xx.h文件。

1. #define PERIPH_BASE           ((uint32_t)0x40000000)
   : X- {: w/ _+ G
2. #define D1_AHB1PERIPH_BASE    (PERIPH_BASE + 0x12000000)
   
3. #define JPEG                  ((JPEG_TypeDef *) JPGDEC_BASE)
   8 n4 h/ l9 N! G1 D
4. #define JPGDEC_BASE           (D1_AHB1PERIPH_BASE + 0x3000) <----- 展开这个宏，(JPEG_TypeDef *) 0x52003000

复制代码

我们访问JPEG的CR寄存器可以采用这种形式：JPEG->CR = 0。

, C' ~; n& u$ a- {/ L57.3.2 JPEG的编解码参数结构体JPEG_ConfTypeDef
此结构体用于JPEG的编解码参数，具体定义如下：

1 A$ V+ B) G5 a4 a/ ?: i1 c

1. typedef struct
   8 S9 G! a/ J2 r% e3 i9 @
2. {
   
3.   uint8_t  ColorSpace;               
   
4.   uint8_t  ChromaSubsampling;        
   
5.   uint32_t ImageHeight;              
   
6.   uint32_t ImageWidth;            
   . x2 R) D+ P. C& J9 n* u
7.   uint8_t  ImageQuality;               
   # @2 n# E3 ]! c: ~
8. }JPEG_ConfTypeDef;

复制代码

下面将这几个参数逐一为大家做个说明：
  uint8_t  ColorSpace


0 l) M5 G8 d2 ?) R* [5 a0 a此参数用于设置输出数据流中的量化表，具体支持的参数如下：
4 f9 ?& y* B2 j% m( |

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 个量化表）*/

复制代码

1 V/ U, V) H: S' f  uint8_t  ChromaSubsampling
此参数用于色度子采样，具体支持的参数如下：

# J  c3 b6 g0 c1 g7 R* ]

1. #define JPEG_444_SUBSAMPLING     ((uint32_t)0x00000000U)   /* 4:4:4 */
   % g3 O# Q. f. `
2. #define JPEG_420_SUBSAMPLING     ((uint32_t)0x00000001U)   /* 4:2:0 */
   
3. #define JPEG_422_SUBSAMPLING     ((uint32_t)0x00000002U)   /* 4:2:2 */

复制代码

9 B  B. D, y) z7 s7 @: E  uint32_t  ImageHeight
此参数用于图像高度。

! H0 N/ R* u9 F  uint32_t ImageWidth
! X1 y# R& P4 g! C+ w2 m4 s3 r) s$ s; G' y此参数用于图像宽度。
; h+ i/ F/ j: [) G1 y* y
  uint8_t  ImageQuality
  K3 P) w: ~1 k) X此参数用于图像质量，参数范围1 – 100，1最差，100最好。
+ X6 x" g9 C( y. Q$ ~
57.3.3 JPEG结构体句柄JPEG_HandleTypeDef
HAL库在JPEG_TypeDef， JPEG_ConfTypeDef的基础上封装了一个结构体JPEG_HandleTypeDef，定义如下：

1. typedef struct
   7 n0 I: j/ F2 j
2. {
   0 J" @: f" g% {
3.   JPEG_TypeDef             *Instance;        
   ) T  U% t* J+ `) n( Y
4.   JPEG_ConfTypeDef         Conf;            
   
5.   uint8_t                  *pJpegInBuffPtr;
   ( B6 r' Y) D& ~! P2 n2 `2 W
6.   uint8_t                  *pJpegOutBuffPtr;
   
7.   __IO uint32_t            JpegInCount;      
   
8.   __IO uint32_t            JpegOutCount;     
   + g+ t, o3 v  m: C
9.   uint32_t                 InDataLength;     
   
10.   uint32_t                 OutDataLength;     
    
11.   MDMA_HandleTypeDef        *hdmain;         
    
12.   MDMA_HandleTypeDef        *hdmaout;        
    , w" ^6 H/ |0 }  E8 E; U
13.   uint8_t                  CustomQuanTable;
    5 v7 A% l+ y' O
14.   uint8_t                  *QuantTable0;   
    / G( }4 z5 {; v) Q& r6 K
15.   uint8_t                  *QuantTable1;   
    ( f8 C* a, }3 M' y3 {% ]
16.   uint8_t                  *QuantTable2;   
    # n6 r: Q( @/ W
17.   uint8_t                  *QuantTable3;         
    5 r6 [6 r8 Q  i6 Q( L- p% r
18.   HAL_LockTypeDef          Lock;            
    ( {. U& N; ^. X* j: ^' T1 J
19.   __IO  HAL_JPEG_STATETypeDef State;         
    . Y6 |8 O6 O- O1 Q) A4 q
20.   __IO  uint32_t           ErrorCode;      
    
21.   __IO uint32_t Context;                    
    * [! S" j' O1 a
22. }JPEG_HandleTypeDef;

复制代码

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

5 m( [' }' \$ R4 y  JPEG_TypeDef   *Instance
这个参数是寄存器的例化，方便操作寄存器，详见本章3.1小节。
6 Q. r: o& e- C+ H8 A$ t' v* q; N
( _0 {# g# N* L/ M& L0 D# R0 g  JPEG_ConfTypeDef   Conf
这个参数是用户接触较多的，用于JPEG的编解码参数，详见本章3.2小节。
4 V2 z/ r; A3 g- G% L+ |
  uint8_t       *pJpegInBuffPtr
JPEG编解码输入缓冲地址

  c/ [: @: V. ]* w; x4 t  uint8_t       *pJpegOutBuffPtr
JPEG编解码输出缓冲地址

! ^8 A4 f# H3 \% i: f8 I4 v! M' T  O9 N  __IO uint32_t   JpegInCount
3 E4 Z, v$ `1 h, K$ F0 aJPEG内部输入计数。
( M& V4 [( o5 g- A* j+ z# }# b
  __IO uint32_t   JpegOutCount
5 Y: @2 `: s& mJPEG内部输出计数。

+ J+ r! T( }! U0 [- v# o  uint32_t        InDataLength
/ q* F0 S4 y- Y* j' X7 }+ YJPEG输入缓冲区长度，单位字节
' e; C4 @* A1 K9 \. f$ W" G! [' c
  uint32_t          OutDataLength
4 n3 P$ @+ ^) f! j2 bJPEG输出缓冲区长度，单位字节。
, k# U- T9 g* T4 O( u4 Q1 q: U
. M: x; }' ?/ }% H  MDMA_HandleTypeDef        *hdmain
: X/ f9 j( y) p; d6 y0 N+ {) E0 q  MDMA_HandleTypeDef        *hdmaout
; |* O, r: k. l/ x2 Y3 r+ U: y$ `: ~$ IMDMA句柄结构体指针变量，用于关联JPEG句柄，方便调用。
8 i- U" \2 x# M* M0 A8 t8 i( q
  uint8_t       CustomQuanTable
) H. c" ~. J6 ~1 l8 E如果此参数设置为1，将使用用户设置的量化表。

, m1 {  U8 B; C! j  uint8_t      *QuantTable0;   
  uint8_t      *QuantTable1;     
  uint8_t      *QuantTable2;   
3 M7 V  g' F7 Z! @  uint8_t      *QuantTable3;
4 _6 P; O2 A9 ?指定量化表地址。   

  HAL_LockTypeDef          Lock           
( U# ]4 L( s, @) H  __IO  HAL_JPEG_STATETypeDef State           
  __IO  uint32_t           ErrorCode      
* E0 O0 h) D$ H: f+ B这三个变量主要供函数内部使用。Lock用于设置锁状态，State用于设置JPEG状态，而ErrorCode用于配置代码错误。
# w1 t4 ^; w7 s. @4 A
  __IO uint32_t Context
JPEG上下文。
# ^" {- x8 Y% b% K) n& O( Z3 Q0 L
4 {; z; x4 V; z4 M% i; j# q  p. i57.3.4 JPEG初始化流程总结
使用方法由HAL库提供：
" o( ?& n9 ^: x4 K
  第1步：调用函数HAL_JPEG_Init进行初始化，但这个函数不需要初始化参数。
! T( ?1 b( G& p7 @  D
1 W2 z( A& R) F( n4 E如果是JPEG编码，可以通过函数HAL_JPEG_ConfigEncoding设置JPEG图像的质量参数，质量越高，生成的JPEG文件越大、
2 I7 f$ `5 A! r1 F8 o
: z& g6 H7 M5 G. Q  z  第2步：调用编解码函数
! Z8 c# N8 X/ ]. r
7 n! w% ]. u! G  查询式编解码函数
* S+ |; j2 M8 D  @* iHAL_JPEG_Encode

& G$ k# R0 F2 v% Y8 f  }1 UHAL_JPEG_Decode
6 s) }, i3 I3 K/ [: j1 @+ g
  ~! D# l* Z2 X/ t: z# I+ |

" n+ t7 T3 `  g' Z: g0 i4 j7 O  中断方式
HAL_JPEG_Encode_IT
: ]% c' I! r. |% \0 X3 q1 N
HAL_JPEG_Decode_IT
& v) b4 V& ^6 w; a7 h: x2 w
+ z' v3 q9 R7 S: s+ D! n1 R/ C0 P
6 n( G" b! Y( X4 i' {: q9 D
, f/ E/ e3 T$ U( o. d8 m! F$ R" x4 P  DMA方式
HAL_JPEG_Encode_DMA

. R# z$ R7 T) V; gHAL_JPEG_Decode_DMA
8 z$ ], i, _% x& p" [8 m0 k: C8 R+ C
/ c' Q( [% x) k, C: L8 I  第4步：如果用户之前的数据已经处理完毕，需要插入新数据，会调用函数HAL_JPEG_GetDataCallback

（1）如果新的数据已经准备好，需要调用函数HAL_JPEG_ConfigInputBuffer。如果新的数据没有准备好，需要等待插入新数据时，可以调用函数HAL_JPEG_Pause（参数XferSelection被设置为JPEG_PAUSE_RESUME_INPUT），待数据准备好后，可以调用HAL_JPEG_ConfigInputBuffer设置新的输入缓冲和大小，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。
! p, @  J3 |/ r
2 c4 K/ q4 u1 p  Y& |$ T如果编解码的数据已经处理完毕，可以调用函数HAL_JPEG_ConfigInputBuffer设置InDataLength参数为0（此函数是在回调函数HAL_JPEG_GetDataCallback里面被调用的）。


' d* p' t4 G5 y8 G' G" T, I（2）函数HAL_JPEG_ConfigInputBuffer/HAL_JPEG_Pause/HAL_JPEG_Resume的工作机制允许应用程序以块为单位提供输入数据。如果新的数据块未准备好，可以调用函数HAL_JPEG_Pause暂停输入，待数据准备好后，可以调用HAL_JPEG_ConfigInputBuffer设置新的输入缓冲和大小，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。
& D4 f, L: D# j* R; u
4 a& g8 o- `( D! K* |4 I( O5 S
（3）新的数据块准备好后，可以在回调函数HAL_JPEG_GetDataCallback外面调用HAL_JPEG_ConfigInputBuffer 和 HAL_JPEG_Resume，但是为了保持数据一致性问题，务必在回调函数HAL_JPEG_GetDataCallback里面调用HAL_JPEG_Resume。


  第5步：输出缓冲区填充了给定大小的数据后，会调用回调函数HAL_JPEG_DataReadyCallback

（1）如果有数据空间存储新数据块，需要调用函数HAL_JPEG_ConfigOutputBuffer配置新存储位置。如果没有数据空间存储新数据块，需要等待有数据空间可用时，可以调用函数HAL_JPEG_Pause（参数XferSelection被设置为JPEG_PAUSE_RESUME_INPUT），待有数据空间可用时，可以调用HAL_JPEG_ConfigOutputBuffe设置新的输出缓冲，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。
; f* n" |0 s  s
（2）函数HAL_JPEG_ConfigOutputBuffe/HAL_JPEG_Pause/HAL_JPEG_Resume的工作机制允许应用程序以块为单位接收数据。当接收到数据块时，应用程序可以暂停JPEG输出来处理这些数据，比如解码时YCbCr转RGB或者编码时数据存储。
8 N- x6 y5 R! a% a
: g1 \9 U! ?; o（3）新的数据空间准备好后，可以在回调函数HAL_JPEG_DataReadyCallback外面调用HAL_JPEG_ConfigOutputBuffer和 HAL_JPEG_Resume，但是为了保持数据一致性问题，务必在回调函数HAL_JPEG_DataReadyCallback里面调用HAL_JPEG_Resume。

2 q& z4 e" ^8 |
  第6步：其它相关函数

  JPEG解码时，如果解码成功，会调用回调函数HAL_JPEG_InfoReadyCallback。
  JPEG编码操作结束后会调用回调函数HAL_JPEG_EncodeCpltCallback。
  JPEG解码操作结束后，会调用回调函数HAL_JPEG_DecodeCpltCallback。
  操作过程中出现错误，会调用回调函数HAL_JPEG_ErrorCallback，用户可以调用函数HAL_JPEG_GetError获取错误类型。
  HAL JPEG默认使用的是ISO/IEC 10918-1规格量化表，如果要修改，可以调用函数HAL_JPEG_SetUserQuantTables实现。
; k- U  z# h+ E$ d% Q  通过函数HAL_JPEG_GetState可以获取JPEG状态。
3 _' ?0 D" x' Y6 R/ \# [
& w* `9 x% c# d" U0 _& r8 g
: {6 V! _8 `9 y57.4 源文件stm32h7xx_hal_jpeg.c
这里把我们把如下几个常用到的函数做个说明：
: R, d/ D3 d( \# ?. F
  HAL_JPEG_Init
, K/ s/ J" A( b  HAL_JPEG_GetInfo
  HAL_JPEG_Decode_DMA
  HAL_JPEG_ConfigInputBuffer
  HAL_JPEG_ConfigOutputBuffer
+ z# Q7 k7 U$ P
; ~8 o; `7 U% \' @4 F% j8 o57.4.1 函数HAL_JPEG_Init
函数原型：
0 H1 O4 x) ]( e8 V* C' T# M( N7 B
0 ~" \$ j+ h, c+ u

1. HAL_StatusTypeDef HAL_JPEG_Init(JPEG_HandleTypeDef *hjpeg)
   3 _' G5 c; w  q, y$ r+ M5 D2 t- u
2. {
   ' @* P6 H( _/ @  a
3.   uint32_t acLum_huffmanTableAddr = (uint32_t)(&JPEG_ACLUM_HuffTable);
   . m, F0 W; r+ T# F3 f
4.   uint32_t dcLum_huffmanTableAddr = (uint32_t)(&JPEG_DCLUM_HuffTable);
   $ B+ R, f- I3 ]2 d4 X, U( }
5.   uint32_t acChrom_huffmanTableAddr = (uint32_t)(&JPEG_ACCHROM_HuffTable);
   
6.   uint32_t dcChrom_huffmanTableAddr = (uint32_t)(&JPEG_DCCHROM_HuffTable);
   
7. 
   ( g& a  m0 B' ^6 [
8.   /* 检测句柄是否有效 */
   4 T2 r; H* m3 m+ Y4 m9 o
9.   if(hjpeg == NULL)
   6 l( R4 F9 r$ ~" j  r% q1 ]1 R9 y0 x
10.   {
    0 O+ r* Q& ]9 \* J( u
11.     return HAL_ERROR;
    
12.   }
    
13. 
    + c  |. {" |+ t* r3 W6 A; m2 u& I' e
14.   if(hjpeg->State == HAL_JPEG_STATE_RESET)
    
15.   {
    . A+ D3 e0 d) Y( H7 @* C$ h0 f  l
16.     hjpeg->Lock = HAL_UNLOCKED;
    " ?  T2 l6 U" K: _- s% T
17. 
    
18.      /* 初始化GPIO，NVIC等 */
    * `% e. a7 P4 \
19.     HAL_JPEG_MspInit(hjpeg);
    
20.   }
    
21. 
    
22.   /* 设置JPEG状态 */
    
23.   hjpeg->State = HAL_JPEG_STATE_BUSY;
    
24. 
    
25.   /* 使能JPEG  */
    
26.   __HAL_JPEG_ENABLE(hjpeg);
    
27. 
    6 q6 _& E4 [" O8 \! V
28.   /* 关闭JPEG编解码处理 */
    
29.   hjpeg->Instance->CONFR0 &=  ~JPEG_CONFR0_START;
    
30. 
    
31.   /* 关闭JPEG所有中断 */
    . U" i* Y& a: L9 b# p1 y. u
32.   __HAL_JPEG_DISABLE_IT(hjpeg,JPEG_INTERRUPT_MASK);
    . w$ Q5 ^( H9 q0 ^* w
33. 
    
34.   /* 清空输入输入FIFO缓冲 */
    
35.   hjpeg->Instance->CR |= JPEG_CR_IFF;
    / h( ~0 g  Y- l5 }$ k' C
36.   hjpeg->Instance->CR |= JPEG_CR_OFF;  
    7 _  @6 W. G, Z% _
37. 
    ) q  i1 Y3 R9 @9 T9 I4 M
38.   /* 清除所有标志 */
    
39.   __HAL_JPEG_CLEAR_FLAG(hjpeg,JPEG_FLAG_ALL);
    
40. 
    1 b$ @0 G; @8 P' S# F" d2 }
41.   /* 初始化默认的量化表 */
    / \9 p/ m: M8 o9 P* H
42.   hjpeg->QuantTable0 = (uint8_t *)((uint32_t)JPEG_LUM_QuantTable);
    
43.   hjpeg->QuantTable1 = (uint8_t *)((uint32_t)JPEG_CHROM_QuantTable);
    * Y) B5 }; }0 h' X
44.   hjpeg->QuantTable2 = NULL;
    
45.   hjpeg->QuantTable3 = NULL;
    
46. 
    
47.   /* 初始化默认的霍夫曼表 */
    . X3 y) |" W+ I9 h7 d; W
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)
    % B, \1 O7 [) W$ B$ a/ S' ~
49.   {
    
50.     hjpeg->ErrorCode = HAL_JPEG_ERROR_HUFF_TABLE;
    $ U  E" }# z8 `
51. 
    # C* s4 H. [6 Z  t0 u
52.     return HAL_ERROR;
    
53.   }
    8 T0 s, c; @" m) {
54. 
    
55.   /* 使能文件头处理 */
    $ s3 p) _4 w9 N( u0 @
56.   hjpeg->Instance->CONFR1 |= JPEG_CONFR1_HDR;
    9 }+ g+ S1 E, L7 h$ W& r0 o. q' P
57. 
    
58.   /* 复位JPEG输入输出计数 */
    
59.   hjpeg->JpegInCount = 0;
    ! v  Q' g9 i9 \5 M1 K1 t
60.   hjpeg->JpegOutCount = 0;
    4 m, E2 t0 k( Z! j  Q# b
61. 
    
62.   /* 设置JPEG就绪 */
    
63.   hjpeg->State = HAL_JPEG_STATE_READY;
    
64. 
    ! M8 q: V" R: p1 V# V( [: n7 s
65.   /* 设置无错误 Reset the JPEG ErrorCode */
    $ f3 C4 R. g5 i5 |/ {: d
66.   hjpeg->ErrorCode = HAL_JPEG_ERROR_NONE;
    
67. 
    
68.   /* 清除上下文 */
    ; A" ]4 L. H& S, {3 m% _
69.   hjpeg->Context = 0;
    2 @4 n9 q2 D9 y; W
70. 
    
71.   /* 返回HAL_OK */
    
72.   return HAL_OK;
    
73. }
    
74. 
    - y5 N/ z( b& _  n( L

复制代码

函数描述：
& c& y# e+ b( P/ b" F8 a
此函数用于初始化JPEG。
4 i7 c9 B; Q- P6 K5 _
6 g- K: b: r+ b9 s1 v' a函数参数：

8 e" J; a; d/ k# D  l8 x2 v+ l  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：

/ C- G. V& b- {函数HAL_JPEG_MspInit用于初始化JPEG的底层时钟、NVIC等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
1 a; g! O/ Z' A2 S7 S& ]! ^8 B) u! N如果形参hjpeg的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量JPEG_HandleTypeDef JpegHandle。
% v3 o# F7 f( N) y; b4 J: E对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_JPEG_STATE_RESET  = 0x00U。

解决办法有三

; n5 L$ h9 |# F( l3 N$ i方法1：用户自己初始JPEG底层。
7 I% D6 F1 K; ]) Y4 O
方法2：定义JPEG_HandleTypeDef JpegHandle为全局变量。

* }( ]5 p9 C1 t7 w方法3：下面的方法

1. if(HAL_JPEG_DeInit(&JpegHandle) != HAL_OK)
   , |" {/ J3 V/ z# ^. D3 e
2. {
   
3.     Error_Handler();
   
4. }  
   * U7 T. k; m$ v; c% t' Z0 P
5. if(HAL_JPEG_Init(&Dma2dHandle) != HAL_OK)
   # r- u6 X+ Y) I. d% T
6. {
   
7.     Error_Handler();
   * `* Q$ P; c' f0 s/ ?
8. }

复制代码

' G7 M% ]7 |$ b: l* a( _使用举例：

1. JPEG_HandleTypeDef    JPEG_Handle;
   
2. JPEG_Handle.Instance = JPEG;
   ' W* v; D: E* x  S# s; K  G! Y5 x
3. HAL_JPEG_Init(&JPEG_Handle);

复制代码

57.4.2 函数HAL_JPEG_GetInfo
; ?2 Q6 i2 T1 y/ o3 v3 v函数原型：

1. HAL_StatusTypeDef HAL_JPEG_GetInfo(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo)
     t/ x) ?, t/ \$ r6 n- E
2. {
   
3.   uint32_t yblockNb, cBblockNb, cRblockNb;
   ' F2 b; n: K) a! m
4. 
   ; C: i) q1 D/ m" s
5.   /* 检测句柄是否有效 */
   
6.   if((hjpeg == NULL) || (pInfo == NULL))
   
7.   {
   
8.     return HAL_ERROR;
   
9.   }
   
10. 
    
11.   /* 读取配置参数 */
    
12.   if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF_1)
    - U8 }- z* D0 u+ L: j
13.   {
    
14.     pInfo->ColorSpace = JPEG_YCBCR_COLORSPACE;   
    0 ], ?% O/ `+ j* }2 |
15.   }   
      H4 O' B& a/ t/ }" f" N
16.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == 0)
    3 L  K0 Q+ E2 s
17.   {
    $ F8 b6 Y0 d9 y
18.     pInfo->ColorSpace = JPEG_GRAYSCALE_COLORSPACE;
    
19.   }
    2 B- C( ?2 D$ U9 L  Z, W9 T
20.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF)
    
21.   {
    
22.     pInfo->ColorSpace = JPEG_CMYK_COLORSPACE;   
    & }1 S) h6 }7 H
23.   }
    
24. 
    
25.   pInfo->ImageHeight = (hjpeg->Instance->CONFR1 & 0xFFFF0000U) >> 16;
    + y1 S/ R$ x" S2 h
26.   pInfo->ImageWidth  = (hjpeg->Instance->CONFR3 & 0xFFFF0000U) >> 16;
    5 i- r2 ?1 J' |! _/ }; K, t0 A
27. 
    1 v6 n# @" I, r) ^, I& H7 T
28.   if((pInfo->ColorSpace == JPEG_YCBCR_COLORSPACE) || (pInfo->ColorSpace == JPEG_CMYK_COLORSPACE))
    
29.   {
    
30.     yblockNb  = (hjpeg->Instance->CONFR4 & JPEG_CONFR4_NB) >> 4;
    $ Z* q" r" ?: j+ {% X2 U
31.     cBblockNb = (hjpeg->Instance->CONFR5 & JPEG_CONFR5_NB) >> 4;
    
32.     cRblockNb = (hjpeg->Instance->CONFR6 & JPEG_CONFR6_NB) >> 4;
    
33. 
    
34.     if((yblockNb == 1) && (cBblockNb == 0) && (cRblockNb == 0))
    
35.     {
    4 S/ X* O+ V! b  B& {3 ]
36.       pInfo->ChromaSubsampling = JPEG_422_SUBSAMPLING; /*16x8 block*/
    
37.     }
    
38.     else if((yblockNb == 0) && (cBblockNb == 0) && (cRblockNb == 0))
    
39.     {
      @( ^$ R+ H. _( o8 D
40.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    
41.     }
    
42.     else if((yblockNb == 3) && (cBblockNb == 0) && (cRblockNb == 0))
    
43.     {
    
44.       pInfo->ChromaSubsampling = JPEG_420_SUBSAMPLING;
    1 _8 z- m* b' N) ]; g1 A
45.     }
    
46.     else /* 默认是 4:4:4*/
    
47.     {
    / \2 L0 r" w; \" c% u3 k
48.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    # A0 Z8 V, x2 r' o2 P
49.     }
    3 A" j5 x- g; q: s1 Z  ~; s8 r
50.   }
    ; X! P* [7 b, ~' }9 p! X* b3 B
51.   else
    0 V7 Z/ |& N* ?$ F8 C
52.   {
    
53.     pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    ; T( W/ R" f7 v. r4 }9 |9 D
54.   }
    
55. 
    
56.   pInfo->ImageQuality = JPEG_GetQuality(hjpeg);
    
57. 
    ' s4 G2 U' D' ]+ N- q- G
58.   /* 返回HAL_OK */
    ) F( M0 k2 i$ Z% A
59.   return HAL_OK;
    
60. }
    

复制代码

函数描述：

( T5 ^$ L+ o1 q0 V此函数主要用于解码JPEG时获取相关图像信息，比如图像质量，图像长宽等。

, c' P4 S8 _) l! b$ O2 ]函数参数：
! w; p: `  ^2 w. Y- m! f  z( M
; \  J( o1 @. c% S  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是JPEG_ConfTypeDef类型结构体指针变量，用于获取JPEG的配置信息，结构体变量成员的详细介绍看本章3.2小
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。


使用举例：

1. JPEG_HandleTypeDef    JPEG_Handle;
   
2. JPEG_ConfTypeDef      JPEG_Info;
   . H/ q6 O$ h% X5 s  j+ l: c5 F
3. 
   
4. HAL_JPEG_GetInfo(&JPEG_Handle, &JPEG_Info);  

复制代码

6 L- L2 a7 o9 ^57.4.3 函数HAL_JPEG_Decode_DMA
函数原型：
# ^8 h1 Z' `5 J# N7 T3 y6 o

1. HAL_StatusTypeDef  HAL_JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg ,uint8_t *pDataIn ,uint32_t InDataLength ,uint8_t *pDataOutMCU ,uint32_t OutDataLength)
   
2. {
   9 i" u% D  ?8 M1 W
3.   /* 检测参数 */
   
4.   assert_param((InDataLength >= 4));
   
5.   assert_param((OutDataLength >= 4));
   
6. 
   ; j* P( _+ K+ C. o# c8 P
7.   /* 检测参数 */
   
8.   if((hjpeg == NULL) || (pDataIn == NULL) || (pDataOutMCU == NULL))
   ) d8 c, I( ?- Y$ B9 |$ E; u/ ]8 _
9.   {
   
10.     return HAL_ERROR;
    
11.   }
    
12. 
    ( M- M$ ^1 t3 a& Z  ^9 Z* k
13.   /* 上锁 */
      b8 ]% Y, {  x' ]8 Q/ a3 b
14.   __HAL_LOCK(hjpeg);
    5 i4 _6 ^* L* m  b! r9 {
15. 
    
16.   if(hjpeg->State == HAL_JPEG_STATE_READY)
    2 I' Z4 D0 A9 c& X  A! U5 W$ I
17.   {
    - w6 H8 R+ ]& B5 g, L; l$ u
18.     /* 设置JPEG忙 */
    5 G2 i8 d5 p* d& H; q
19.     hjpeg->State = HAL_JPEG_STATE_BUSY_DECODING;
    , p7 [' S2 s& d
20. 
    , V, {4 ]3 x- U; J0 H4 e* K
21.     /* 设置JPEG上下文，工作在DMA界面状态 */
    2 I: B- z/ Y, t; M; f
22.     hjpeg->Context &= ~(JPEG_CONTEXT_OPERATION_MASK | JPEG_CONTEXT_METHOD_MASK);
    
23.     hjpeg->Context |= (JPEG_CONTEXT_DECODE | JPEG_CONTEXT_DMA);         
    ! q3 B! ^/ f- e& z+ _
24. 
    2 j( m1 G$ z4 ^; u! R) I& V- y
25.     /* 设置输入输出缓冲地址和大小 */
    8 g" }- Q2 ]% ~$ a$ Y7 j5 s- Q7 ]
26.     hjpeg->pJpegInBuffPtr = pDataIn;
    ; J- i3 [3 N& Y6 k* E3 b
27.     hjpeg->pJpegOutBuffPtr = pDataOutMCU;
    6 w# ~1 M+ F6 H& L0 w
28.     hjpeg->InDataLength = InDataLength;
    
29.     hjpeg->OutDataLength = OutDataLength;
    
30. 
    7 ~/ q: `/ e$ K/ q' _. l; v
31.     /* 复位输入输出缓冲计数 */
    
32.     hjpeg->JpegInCount = 0;   
    
33.     hjpeg->JpegOutCount = 0;   
    " N  ?5 q1 J: N5 q$ G# D" c
34. 
    
35.     /* 初始化解码处理 */
    
36.     JPEG_Init_Process(hjpeg);
    # u1 G* r3 p% j3 @' z% S: l4 Q
37. 
    . X6 _' k" i8 X( K* _
38.     /* 启动JPEG解码处理，使用DMA方式 */
    
39.     JPEG_DMA_StartProcess(hjpeg);
    . i6 Y. d4 X* b" C4 H3 f( M
40. 
    6 k- X6 k4 G" i0 {* M: Q, a
41.   }
    
42.   else
    7 O$ m  {7 @* Q) V+ [  y' V; e
43.   {
    
44.     /* 解锁 */
    ) r) n0 _8 j- o- U  g# h
45.     __HAL_UNLOCK(hjpeg);
    
46. 
    
47.     return HAL_BUSY;
    
48.   }
    . i/ d* C  t! K- E
49. 
    $ `- M7 h; R5 U; W; y
50.   /* 返回HAL_OK */
    
51.   return HAL_OK;
    
52. }
    

复制代码

, m5 b0 k# ~% w$ a. G* Z
# ^! f: h- i4 d. v函数描述：

4 ^3 c  g  c. T, D' r5 e3 `5 ?7 I6 }此函数用于启动JPEG的DMA方式解码。
; F% I4 O/ c0 D, c& \  @: P$ ]
* {* v, p- e: F函数参数：

4 O. {/ D, x1 W# h7 K% {+ e  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是输入数据缓冲地址。
1 `; j" g- `/ }& ?  第3个参数输入数据大小，单位字节。
5 u0 A* p7 V" U- I  第4个参数是输出缓冲地址。
  第5个参数是输出缓冲大小，单位字节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
4 [: V2 s8 A/ F' B% }
使用举例：

) C8 d2 v' x& s

1. /*
   
2. *********************************************************************************************************
   4 u5 \) c3 E3 D
3. *    函 数 名: JPEG_Decode_DMA
   ) S0 H: ?9 N+ N" c1 P+ P! c
4. *    功能说明: JPEG解码
   
5. *    形    参: hjpeg               JPEG_HandleTypeDef句柄指针
   % O! T' H1 y7 V" U* R
6. *             FrameSourceAddress  数据地址
   
7. *             FrameSize           数据大小
   
8. *             DestAddress         目的数据地址
   
9. *    返 回 值: HAL_ERROR表示配置失败，HAL_OK表示配置成功
   " k8 O0 l. M% i& W# W
10. *             HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出
    * T' S7 C$ P- b; J3 d
11. *********************************************************************************************************
    
12. */
    6 K* c, T8 z& @- l# K$ X4 d0 W! J
13. uint32_t JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg, uint32_t FrameSourceAddress ,uint32_t FrameSize, uint32_t DestAddress)
    
14. {
    ; D3 s6 w3 @# s0 d8 L
15.     JPEGSourceAddress =  FrameSourceAddress ;
    
16.     FrameBufferAddress = DestAddress;
    
17.     Input_frameIndex = 0;
    
18.     Input_frameSize = FrameSize;
    
19. 
    
20.     /* 设置标志，0表示开始解码，1表示解码完成 */
    
21.     Jpeg_HWDecodingEnd = 0;
    7 u! i! P+ `+ F  ]% ~# D
22. 
    ; N1 ]' C% p3 L  w
23.     /* 启动JPEG解码 */
    ' g1 m$ `" k  u. a. Q, N% v6 D  x
24.     HAL_JPEG_Decode_DMA(hjpeg ,(uint8_t *)JPEGSourceAddress ,CHUNK_SIZE_IN ,
    " `) J$ i; N4 t4 z0 }% F" m
25. (uint8_t *)FrameBufferAddress ,CHUNK_SIZE_OUT);
    9 s0 ~9 I/ u6 n( @$ Z7 S% s
26. 
    
27.     return HAL_OK;
      }1 _% d9 ]( N3 X( q1 r1 W
28. }

复制代码

, R8 R8 I+ u# F/ M5 d57.4.4 函数HAL_JPEG_ConfigInputBuffer
函数原型：

8 v" A8 K9 {' ^+ m

1. void HAL_JPEG_ConfigInputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewInputBuffer, uint32_t InDataLength)
   9 F( J8 P" g# q6 D4 ~+ a$ U
2. {
   " ~$ g* r; d" y, x3 N4 `$ Z
3.   hjpeg->pJpegInBuffPtr =  pNewInputBuffer;
   : p* H4 p3 ]# @" Y* ~
4.   hjpeg->InDataLength = InDataLength;
   3 @2 {7 D) t" l) v$ v# u
5. }

复制代码

函数描述：

此函数用于配置编解码输入缓冲地址和数据大小。
! l6 z! X. `+ k; _2 F
函数参数：
! ?% b" X9 k" n1 R$ ]
  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是输入缓冲地址。
' |' R. M. a$ a, ~' K. p  R) @5 g+ E+ ~  第3个参数是输入缓冲大小，单位字节。
( c6 d  W1 R  Q: z* H& ]  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
* L2 e+ J9 ~! \9 E使用举例：
2 W) I+ U) m  ?" `

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: HAL_JPEG_GetDataCallback
   
4. *    功能说明: JPEG回调函数，用于从输入地址获取新数据继续解码
   + T' ^5 \. D4 h
5. *    形    参: hjpeg          JPEG_HandleTypeDef 句柄指针
   
6. *             NbDecodedData  上一轮已经解码的数据大小，单位字节  
   
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   : c% N# R) b* V8 L4 L6 _
9. */
   
10. void HAL_JPEG_GetDataCallback(JPEG_HandleTypeDef *hjpeg, uint32_t NbDecodedData)
    ' N( x( T, B# H& O+ {$ M# f
11. {
    
12.     uint32_t inDataLength;
    
13. 
    4 |" q0 C0 y0 @, l* R( E
14.     /* 更新已经解码的数据大小 */
    
15.     Input_frameIndex += NbDecodedData;
    : E2 A: V! C+ ~
16. 
    9 g/ E: S+ r- h' Q* p) u6 N) V5 N
17.     /* 如果当前已经解码的数据小于总文件大小，继续解码 */
    ' D/ D+ ?) V+ U* o
18.     if( Input_frameIndex < Input_frameSize)
    + M9 \2 N& Q% _& T/ P
19.     {
    
20.         /* 更新解码数据位置 */
    1 ^9 o' g) f" x2 P) W: P
21.         JPEGSourceAddress = JPEGSourceAddress + NbDecodedData;
    # D+ o4 [9 V2 z. O% R: r1 E
22. 
    
23.         /* 更新下一轮要解码的数据大小 */
    
24.         if((Input_frameSize - Input_frameIndex) >= CHUNK_SIZE_IN)
    ( o, s% w  i: ~* A0 T: B
25.         {
    + U' z4 m6 a  W0 n1 d6 E: V- @
26.             inDataLength = CHUNK_SIZE_IN;
    0 r8 {5 K2 Z4 i2 S
27.         }
    
28.         else
    
29.         {
    
30.             inDataLength = Input_frameSize - Input_frameIndex;
    
31.         }   
    
32.     }
    8 }% `) M% |7 K
33.     else
    + W5 c  \( @. J! I8 X3 s1 @
34.     {
    
35.         inDataLength = 0;
    " I2 W2 N7 E. I% A- x% Z
36.     }
    , J: C8 I; o9 L* r1 L# i- E
37. 
    
38.     /* 更新输入缓冲 */
    
39.     HAL_JPEG_ConfigInputBuffer(hjpeg,(uint8_t *)JPEGSourceAddress, inDataLength);   
    
40. }

复制代码

57.4.5 函数HAL_JPEG_ConfigOutputBuffer
$ ^, ^, l' x; v9 \' Z! ^函数原型：

1 G2 O( m! i) }2 S

1. void HAL_JPEG_ConfigOutputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewOutputBuffer, uint32_t OutDataLength)
   2 f4 W  ?2 z% ^) a$ ^, o
2. {
   8 [( a8 w0 C* M2 M0 t1 L: O
3.   hjpeg->pJpegOutBuffPtr = pNewOutputBuffer;
   
4.   hjpeg->OutDataLength = OutDataLength;  
   7 l1 V" z$ O5 g2 M- t
5. }

复制代码

) _; m( B/ b( w+ H  ^
函数描述：

此函数用于配置编解码输出缓冲地址和数据大小。

$ U) O$ d9 I- i. M8 _1 ?) P函数参数：
/ C2 v( Y! q0 P( `9 e" b
  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是输出缓冲地址。
. Z& z" Q: \& g' }5 D% @& l, w  第3个参数是输出缓冲大小，单位字节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
& F% W8 w9 t/ x, }, s: r使用举例：
8 g9 k4 X3 W4 c9 E% W
. [' V# A, d5 c$ H

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: HAL_JPEG_DataReadyCallback
   % m% q. V$ T* `# e/ F0 o
4. *    功能说明: JPEG回调函数，用于输出缓冲地址更新
   
5. *    形    参: hjpeg         JPEG_HandleTypeDef 句柄指针
   / t+ C2 v' z/ L; s  H
6. *             pDataOut      输出数据缓冲
   
7. *             OutDataLength 输出数据大小，单位字节
   4 T4 b0 K# R3 P
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   # j0 j5 m, B' N% H: [+ o5 Y
10. */
    - x+ T9 F- s7 r# Q  g
11. void HAL_JPEG_DataReadyCallback (JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, uint32_t OutDataLength)
    
12. {
    # Y: w1 ^  Y9 J
13.     /* 更新JPEG输出地址 */  
    
14.     FrameBufferAddress += OutDataLength;
    
15. 
    
16.     HAL_JPEG_ConfigOutputBuffer(hjpeg, (uint8_t *)FrameBufferAddress, CHUNK_SIZE_OUT);
    
17. }

复制代码

57.5 总结
本章节就为大家讲解这么多，JPEG功能用到的地方还是比较多的，建议熟练使用。

8 \: T3 v1 G0 k1 M
1 ?; H( T  z+ B5 T# i; X