57.1 初学者重要提示
  由于硬件JPEG解码后输出的图像格式是YCbCr，所以本章对YCbCr进行了重点介绍。
# A# L; ]; q; M" h1 v. z3 _  测试STM32H7硬件JPEG解码800*480图片性能，全部通过SDRAM缓存数据，解码10ms，显示9ms。
  JPEG涉及到的知识点还是比较多的，如果想深入了解JPEG的话，可以看本章2.6小节给的参考资料。
$ E' L4 l" R1 X1 x: k# y  本章JPEG相关概念的介绍参考了wiki百科和百度百科。
3 t- ^7 k5 s- v0 w4 _$ Z57.2 硬件JPEG基础知识
对于STM32H7的硬件JPEG了解到以下几点即可：
# o2 C+ T  T" G  k2 ~
6 n9 g4 y# x# N, M) W  支持JPEG解码和编码。
  对每个像素数据进行编解码只需一个时钟周期。
  支持RGB、 YCbCr、YCMK和BW（灰度）图像色彩模型。
  编解码时每图像分量8位深度。
( e! W: ?4 \9 D% M) @9 O5 |
7 [7 H, [! P3 j2 r; ~; H57.2.1 JPEG硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速地了解JPEG的基本功能，然后再看手册了解细节。框图如下所示：
1 E% |- r7 p! C3 M# _
4 t: T, l- y& M- J" V3 I* L; U

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

  JPEG硬件外设支持编码和解码
并且对于输入数据和输出数据都有FIFO支持。

  jpeg_hclk
为JPEG内核和寄存器提供时钟。

  jpeg_it
8 Y, s3 x' Z; e8 M( \5 h2 Z6 H/ K2 IJPEG全局中断输出。

  jpeg_ift_trg
4 n9 ]* R- ^! FJPEG输入FIFO阈值信号，可触发MDMA。
, d6 S  p$ T. _- s  M4 d& U' j
/ _# H7 Z' E; S; K  jpeg_ifnf_trg
/ b  x  W! y$ U9 cJPEG输入FIFO未满信号，可触发MDMA。

  jpeg_oft_trg
3 g0 M2 [; Q) s5 ]& w6 AJPEG输出FIFO阀值信号，可触发MDMA。
- a4 g+ ~6 W: ~1 k1 L- i
  jpeg_ofne_trg
JPEG输出FIFO非空信号，可触发MDMA。
) J; ]! J7 U% p& G! ?% e% ^
  jpeg_oec_trg
/ r6 Z: [( k7 O4 P  L9 oJPEG转换结束信号，可触发MDMA。
# d% q7 u2 j2 G
1 G4 [0 k# _5 \% _57.2.2 YCbCr颜色格式
（注，硬件JPEG解码后输出的图像格式是YCbCr，所以有必要了解下）

7 H" q' l! Q5 h正如几何上用坐标空间来描述坐标集，而色彩空间用数学方式来描述颜色集。常见的3种色彩模型是RGB，CMYK和YUV。

) J+ j- g! Q: k, n+ z( mYCbCr是YUV经过缩放和修改的翻版，只是在表示方法上不同。其中Y是指亮度分量，Cb指蓝色色度分量，而Cr指红色色度分量。人眼对视频的Y分量更敏感，因此通过对色度分量进行子采样来减少色度分量后，人眼察觉不到的图像质量的变化。

% [  @9 b' Z% h: ^2 X6 r在YUV 家族中，YCbCr 是在计算机系统中应用最多的成员，其应用领域广泛，JPEG、MPEG均采用此格式。一般人们所讲的YUV大多是指YCbCr。
6 E0 I" R+ Z  I5 j
57.2.3 YCbCr采样格式
4 y% s4 Y. \! k4 J+ v6 ~YCbCr有许多取样格式，如YCbCr 4:4:4，YCbCr 4:2:2，YCbCr 4:1:1 和YCbCr 4:2:0。
; v/ R0 x' ^  W
  4:2:0
表示每4个像素有4个亮度分量，2个色度分量 (YYYYCbCr），仅采样奇数扫描线，是便携式视频设备（MPEG-4）以及电视会议（H.263）最常用格式。
) a% _6 m% U, m$ ]- V. y: s
  4:2:2
5 y) S; G( q# K: V$ U表示每4个像素有4个亮度分量，4个色度分量（YYYYCbCrCbCr），是DVD、数字电视、HDTV以及其它消费类视频设备的最常用格式。
2 f# W9 s# P' ~6 C
  4:4:4
  k% s' O0 M6 R* Q0 x表示全像素点阵(YYYYCbCrCbCrCbCrCbCr），用于高质量视频应用、演播室以及专业视频产品。
' P; {: x: `/ \1 J0 L9 Y; T
具体的采样方式如下图所示，以8个像素为一个单元进行采样：

" h$ X3 T: z# G0 l& u4 q6 i  ]' h$ o
由上面的截图可以了解到：

4:4:4表示Y通道，Cb+Cr通道全部采样。

4:2:2表示Y通道全部采样，而Cb+Cr通道两个像素为一组，统一采用第1个颜色值。
6 w" O) s5 x4 Y1 \& L! }, ~
1 S' t# l+ i( X4:2:0表示Y通道全部采样，而Cb+Cr通道四个像素为一组，统一采用第1个颜色值。
$ @$ L& J- ?" Z/ i  h! S3 C
0 N. p$ L2 L4 G! C$ v3 R下面是整体效果，方便大家更好的理解：

) x8 B$ m  b: k" ?5 ~


# t* @% f9 K; {; J8 S+ V' k57.2.4 YCbCr的优势
5 D/ |* S8 j6 l- @3 x8 pRGB信号作为存储和传输的效率不高，因为它们具有大量冗余信息。而使用YCbCr可以丢弃一些信息以减少带宽，因为人的肉眼对视频的Y分量更敏感，因此通过对色度分量进行子采样来减少色度分量后，肉眼察觉不到的图像质量的变化。了解这种人为缺点，NTSC和PAL等标准大大降低了色度通道的带宽。
& a( I0 Z9 w7 M/ Q% ^# L: r
57.2.5 YCbCr和RGB互转
为了方便大家更好的了解YCbCr和RGB图像的实际效果，特此搜集整理了两个截图（来自WIKI百科）。下面是图像转YCBCR的效果：四个图，从上到下依次是原始图像，Y通道，Cb通道和Cr通道。
" ^7 U; ^7 b& A

下面是一幅图像分别以R，G，B通道和Y，CB，CR通道的方式展示：
9 o% c6 l6 N4 J5 J+ F% W
$ I8 V2 U& J9 f$ F7 a9 n6 r1 N% b

2 T1 y! _7 ]5 _: I4 D: U! Y8 |57.2.6 JPEG编解码知识
JPEG涉及到的知识点比较多，这里有之前整理的20多个专题知识点，大家有兴趣可以了解下（不了解也没有关系，不影响使用硬件JPEG外设）
: i4 ]; ]# r4 S& T( R8 k
57.3 硬件JPEG的HAL库用法
2 S8 C3 B; D+ C6 q' J' k: k2 pJPEG的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置时钟，并根据需要配置NVIC、中断和MDMA。下面我们逐一展开为大家做个说明。
0 a; ^& B- b5 c/ A: S/ m
57.3.1 JPEG寄存器结构体JPEG_TypeDef
0 U* l; m5 J0 [* v- E2 w2 y% c2 zJPEG相关的寄存器是通过HAL库中的结构体JPEG_TypeDef定义的，在stm32h743xx.h中可以找到它们的具体定义：
6 c: |) v: Q1 Y! V5 r( _" k
: U) U7 T4 |" P0 x

1. typedef struct
   
2. {
   8 u& ?8 a5 {/ ^2 L' U) o
3.   __IO uint32_t CONFR0;         
   * I. w3 T+ t+ e
4.   __IO uint32_t CONFR1;         
   
5.   __IO uint32_t CONFR2;        
   
6.   __IO uint32_t CONFR3;        
   
7.   __IO uint32_t CONFR4;         
   
8.   __IO uint32_t CONFR5;      
   - B- G2 E8 o) D0 |- ]
9.   __IO uint32_t CONFR6;      
   7 e$ E( o5 A+ P$ I
10.   __IO uint32_t CONFR7;        
    
11.   uint32_t  Reserved20[4];      
    + O  b; L* M, v' ~7 s' {  Y
12.   __IO uint32_t CR;            
    2 z& g, I/ j; J
13.   __IO uint32_t SR;            
    
14.   __IO uint32_t CFR;            
    
15.   uint32_t  Reserved3c;        
    % v( K0 ^& z& F* V5 }4 p+ d
16.   __IO uint32_t DIR;         
    
17.   __IO uint32_t DOR;            
    " {  }6 s5 H( s2 o2 S+ I
18.   uint32_t  Reserved48[2];      
    
19.   __IO uint32_t QMEM0[16];     
    
20.   __IO uint32_t QMEM1[16];      
    
21.   __IO uint32_t QMEM2[16];      
    
22.   __IO uint32_t QMEM3[16];      
    
23.   __IO uint32_t HUFFMIN[16];   
    # n# _- h  j1 z! I# U2 b3 _& J
24.   __IO uint32_t HUFFBASE[32];   
    $ ~! U. ]9 G2 N: k/ y7 V
25.   __IO uint32_t HUFFSYMB[84];   
    $ a9 _) A" i- {! ^1 P- x& }1 a
26.   __IO uint32_t DHTMEM[103];   
    3 Q, G& p, y0 c0 t5 ^6 N+ c1 T
27.   uint32_t  Reserved4FC;      
    $ M8 L( u5 [5 D9 A! t3 v" r
28.   __IO uint32_t HUFFENC_AC0[88];
    
29.   __IO uint32_t HUFFENC_AC1[88];
    + A9 K0 Q" O: q; ]# T3 p" d2 \
30.   __IO uint32_t HUFFENC_DC0[8];  
    
31.   __IO uint32_t HUFFENC_DC1[8];
    
32. } JPEG_TypeDef;

复制代码

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

7 Y4 u/ X1 V3 n& h0 E

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

复制代码

下面我们再看JPEG的定义，在stm32h743xx.h文件。

1. #define PERIPH_BASE           ((uint32_t)0x40000000)
   
2. #define D1_AHB1PERIPH_BASE    (PERIPH_BASE + 0x12000000)
   1 O0 d! q4 V( u2 c; d
3. #define JPEG                  ((JPEG_TypeDef *) JPGDEC_BASE)
   
4. #define JPGDEC_BASE           (D1_AHB1PERIPH_BASE + 0x3000) <----- 展开这个宏，(JPEG_TypeDef *) 0x52003000

复制代码

" p& y' o4 O% Y- {4 z+ O我们访问JPEG的CR寄存器可以采用这种形式：JPEG->CR = 0。

57.3.2 JPEG的编解码参数结构体JPEG_ConfTypeDef
此结构体用于JPEG的编解码参数，具体定义如下：
. N" l5 V8 D. y9 i2 M# a

1. typedef struct
   
2. {
   5 X" y& [+ u% N8 m
3.   uint8_t  ColorSpace;               
   
4.   uint8_t  ChromaSubsampling;        
   ! f9 k5 t6 O" O' b) V1 `
5.   uint32_t ImageHeight;              
   
6.   uint32_t ImageWidth;            
   
7.   uint8_t  ImageQuality;               
   
8. }JPEG_ConfTypeDef;

复制代码

4 M1 H. x: ^0 L/ ~. t下面将这几个参数逐一为大家做个说明：
  uint8_t  ColorSpace
  @5 _9 c) ^# H/ E" |6 P9 x/ A7 b

此参数用于设置输出数据流中的量化表，具体支持的参数如下：

1. #define JPEG_GRAYSCALE_COLORSPACE     ((uint32_t)0x00000000U)    /* 灰度（1 个量化表）*/
   
2. #define JPEG_YCBCR_COLORSPACE         JPEG_CONFR1_COLORSPACE_0   /* YUV（2 个量化表） */
   % [3 _' r* p3 n- k1 ]- P) v
3. #define JPEG_CMYK_COLORSPACE          JPEG_CONFR1_COLORSPACE     /* CMYK（4 个量化表）*/

复制代码

  uint8_t  ChromaSubsampling
9 T# C# ]) W& `- Q2 S) e/ P此参数用于色度子采样，具体支持的参数如下：
8 P) z- a0 S# @9 G& y

1. #define JPEG_444_SUBSAMPLING     ((uint32_t)0x00000000U)   /* 4:4:4 */
   5 w4 _  O  D3 G8 S4 ?6 a% }* w" L
2. #define JPEG_420_SUBSAMPLING     ((uint32_t)0x00000001U)   /* 4:2:0 */
   
3. #define JPEG_422_SUBSAMPLING     ((uint32_t)0x00000002U)   /* 4:2:2 */

复制代码

1 d$ [& W& \; V, \' t$ P& m  uint32_t  ImageHeight
. p" B3 G+ F3 S; [6 X* }' K3 N5 ?此参数用于图像高度。

  uint32_t ImageWidth
此参数用于图像宽度。
! F  }5 C* i9 G6 X% S2 Q
2 z6 H6 i! f5 }' J) ^: ?  uint8_t  ImageQuality
+ T# c: P% `% L( X" ]此参数用于图像质量，参数范围1 – 100，1最差，100最好。
2 s4 ?5 l5 x6 S; B6 H0 X- L
57.3.3 JPEG结构体句柄JPEG_HandleTypeDef
HAL库在JPEG_TypeDef， JPEG_ConfTypeDef的基础上封装了一个结构体JPEG_HandleTypeDef，定义如下：

# x- B* O& r6 j1 Y- y8 @

1. typedef struct
   
2. {
   
3.   JPEG_TypeDef             *Instance;        
   9 j8 N( R5 z+ |( E4 }. o
4.   JPEG_ConfTypeDef         Conf;            
   
5.   uint8_t                  *pJpegInBuffPtr;
   
6.   uint8_t                  *pJpegOutBuffPtr;
   
7.   __IO uint32_t            JpegInCount;      
   
8.   __IO uint32_t            JpegOutCount;     
   7 t9 g1 y% B/ F
9.   uint32_t                 InDataLength;     
   : M* f# T6 W! \0 Q4 c8 S
10.   uint32_t                 OutDataLength;     
    
11.   MDMA_HandleTypeDef        *hdmain;         
    
12.   MDMA_HandleTypeDef        *hdmaout;        
    
13.   uint8_t                  CustomQuanTable;
    - \* W6 f6 ]+ [; W+ ?" c# I
14.   uint8_t                  *QuantTable0;   
    
15.   uint8_t                  *QuantTable1;   
    . Y' M4 ]" X5 y! {4 K/ D9 q
16.   uint8_t                  *QuantTable2;   
    
17.   uint8_t                  *QuantTable3;         
    % ?" }! S' K$ T6 r( J) r; `2 I
18.   HAL_LockTypeDef          Lock;            
    2 F/ m' a/ v7 b; F7 }
19.   __IO  HAL_JPEG_STATETypeDef State;         
    
20.   __IO  uint32_t           ErrorCode;      
    ' |- A+ S. Q# I8 K
21.   __IO uint32_t Context;                    
    
22. }JPEG_HandleTypeDef;

复制代码

下面将这几个参数逐一做个说明。
4 u1 v% E/ b  b
  JPEG_TypeDef   *Instance
这个参数是寄存器的例化，方便操作寄存器，详见本章3.1小节。
# e. ^( H/ z: W2 N3 H) ?( k
  JPEG_ConfTypeDef   Conf
" N; T) p* B4 `5 `  _% p. J这个参数是用户接触较多的，用于JPEG的编解码参数，详见本章3.2小节。

  s3 s/ ?9 @4 t) X7 O- _  uint8_t       *pJpegInBuffPtr
JPEG编解码输入缓冲地址

  uint8_t       *pJpegOutBuffPtr
8 a9 |/ L7 x7 o( r) ^+ }' iJPEG编解码输出缓冲地址

  __IO uint32_t   JpegInCount
JPEG内部输入计数。

( A# r% K- B, ^  Y! m  __IO uint32_t   JpegOutCount
JPEG内部输出计数。
) R  s5 Q$ D) |' m
  uint32_t        InDataLength
JPEG输入缓冲区长度，单位字节

6 {8 V% Y! N/ m* j" z) B: m  uint32_t          OutDataLength
JPEG输出缓冲区长度，单位字节。
  g5 ^4 b) D( I! u' U/ a- N
( J! [7 ]$ W) w2 ~2 j" K  MDMA_HandleTypeDef        *hdmain
2 _8 M( }9 {2 e* _4 P  T+ X, G5 t  MDMA_HandleTypeDef        *hdmaout
MDMA句柄结构体指针变量，用于关联JPEG句柄，方便调用。
" v+ e1 Y2 K4 ~3 ]' m7 V5 I
4 B+ R: a$ r8 B  o+ ^  uint8_t       CustomQuanTable
如果此参数设置为1，将使用用户设置的量化表。

  uint8_t      *QuantTable0;   
  uint8_t      *QuantTable1;     
  uint8_t      *QuantTable2;   
, U4 \# W5 o4 l! p. h1 H5 X: x# m  uint8_t      *QuantTable3;
指定量化表地址。   

  HAL_LockTypeDef          Lock           
/ p# i; ?, K3 R  __IO  HAL_JPEG_STATETypeDef State           
  __IO  uint32_t           ErrorCode      
2 q' }) t* C0 N这三个变量主要供函数内部使用。Lock用于设置锁状态，State用于设置JPEG状态，而ErrorCode用于配置代码错误。

1 u) r% E  i. a6 F  S9 ~  __IO uint32_t Context
* ^4 z) a3 a3 B! B" M$ r7 |, W5 qJPEG上下文。
* Y: H& R" k* [: H/ I: r
57.3.4 JPEG初始化流程总结
使用方法由HAL库提供：

$ u+ w+ q, U( l9 z1 f; ^  第1步：调用函数HAL_JPEG_Init进行初始化，但这个函数不需要初始化参数。
# U+ T! r3 G) d
如果是JPEG编码，可以通过函数HAL_JPEG_ConfigEncoding设置JPEG图像的质量参数，质量越高，生成的JPEG文件越大、
, m. ?' S# ~' \1 O3 k% e
  第2步：调用编解码函数

  查询式编解码函数
HAL_JPEG_Encode

3 z) R0 [$ a2 G6 e" \HAL_JPEG_Decode

1 {; I* [# J" i# j& ~  ~: C
/ P6 s2 _/ o6 _) }
  中断方式
- h1 ]) f- O& ^5 ]2 q! T" e8 l1 MHAL_JPEG_Encode_IT
2 {; U* E4 z1 y; C% C5 r
1 `& \; Y6 t9 h1 M- g5 J) i- kHAL_JPEG_Decode_IT

. T( {2 r$ \$ d2 n, F; B
) m1 r+ U/ |4 l, ]: B9 b: X% i
  DMA方式
$ v$ [0 c$ Q& S+ b0 Q  wHAL_JPEG_Encode_DMA
6 t2 G& b& v  [9 u: D4 I8 f
2 Q7 X# x) z4 b3 O2 X2 PHAL_JPEG_Decode_DMA
" o6 w/ Q( Y' p+ I
' U" S3 i* ?% X0 ]1 y; R) a  第4步：如果用户之前的数据已经处理完毕，需要插入新数据，会调用函数HAL_JPEG_GetDataCallback
3 A  U9 `$ I3 ]4 ?: n8 _
, c- L, O7 |- F（1）如果新的数据已经准备好，需要调用函数HAL_JPEG_ConfigInputBuffer。如果新的数据没有准备好，需要等待插入新数据时，可以调用函数HAL_JPEG_Pause（参数XferSelection被设置为JPEG_PAUSE_RESUME_INPUT），待数据准备好后，可以调用HAL_JPEG_ConfigInputBuffer设置新的输入缓冲和大小，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。

1 q' K" Q6 Q  h/ A8 x如果编解码的数据已经处理完毕，可以调用函数HAL_JPEG_ConfigInputBuffer设置InDataLength参数为0（此函数是在回调函数HAL_JPEG_GetDataCallback里面被调用的）。
# M+ f& `  s; o" [# R

* d1 o" O5 i$ Z& C) @（2）函数HAL_JPEG_ConfigInputBuffer/HAL_JPEG_Pause/HAL_JPEG_Resume的工作机制允许应用程序以块为单位提供输入数据。如果新的数据块未准备好，可以调用函数HAL_JPEG_Pause暂停输入，待数据准备好后，可以调用HAL_JPEG_ConfigInputBuffer设置新的输入缓冲和大小，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。


6 b! V4 J1 _4 E0 V% m( s8 W# X（3）新的数据块准备好后，可以在回调函数HAL_JPEG_GetDataCallback外面调用HAL_JPEG_ConfigInputBuffer 和 HAL_JPEG_Resume，但是为了保持数据一致性问题，务必在回调函数HAL_JPEG_GetDataCallback里面调用HAL_JPEG_Resume。
7 r& @/ O* ?9 |6 C; k/ f5 ?
9 r! o  ?9 g: r
$ x/ _; M4 R4 f  第5步：输出缓冲区填充了给定大小的数据后，会调用回调函数HAL_JPEG_DataReadyCallback

4 R4 s* G- K, t, u1 L（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或者编码时数据存储。

5 d9 n0 ?% Q- Q% D（3）新的数据空间准备好后，可以在回调函数HAL_JPEG_DataReadyCallback外面调用HAL_JPEG_ConfigOutputBuffer和 HAL_JPEG_Resume，但是为了保持数据一致性问题，务必在回调函数HAL_JPEG_DataReadyCallback里面调用HAL_JPEG_Resume。

( e- m6 @" l9 J' h1 ]% r
/ s, ^( V2 M/ L" E  第6步：其它相关函数
) p/ A& }/ W/ s
* J) ?4 X' v1 u; U' z+ x& v  JPEG解码时，如果解码成功，会调用回调函数HAL_JPEG_InfoReadyCallback。
5 V# `, l4 t0 d0 o  JPEG编码操作结束后会调用回调函数HAL_JPEG_EncodeCpltCallback。
  JPEG解码操作结束后，会调用回调函数HAL_JPEG_DecodeCpltCallback。
6 {2 I  H& o3 s  M; X" n2 D* ]3 d  操作过程中出现错误，会调用回调函数HAL_JPEG_ErrorCallback，用户可以调用函数HAL_JPEG_GetError获取错误类型。
  R0 A- G# s8 Y3 T/ r+ j  HAL JPEG默认使用的是ISO/IEC 10918-1规格量化表，如果要修改，可以调用函数HAL_JPEG_SetUserQuantTables实现。
# _, M* {6 L. h2 s) W2 @2 U  通过函数HAL_JPEG_GetState可以获取JPEG状态。

! t" o+ L0 ], k  N# _
* i1 P8 p' ]" ~57.4 源文件stm32h7xx_hal_jpeg.c
0 B9 o' a7 k# a; X  J8 D2 G4 h* j这里把我们把如下几个常用到的函数做个说明：
( T( l8 O1 a2 D
  HAL_JPEG_Init
  HAL_JPEG_GetInfo
  HAL_JPEG_Decode_DMA
  HAL_JPEG_ConfigInputBuffer
6 r* i" {6 I4 `: C/ q  HAL_JPEG_ConfigOutputBuffer
; ?" R* d. r" d2 W1 s1 A& X
( U  o9 @8 z# U# T1 @' O7 ^4 x57.4.1 函数HAL_JPEG_Init
函数原型：
8 f1 F* U2 X& x2 q/ J& a; p
9 ^6 R2 c$ s1 p5 g" C' F

1. HAL_StatusTypeDef HAL_JPEG_Init(JPEG_HandleTypeDef *hjpeg)
   
2. {
   
3.   uint32_t acLum_huffmanTableAddr = (uint32_t)(&JPEG_ACLUM_HuffTable);
   , B1 I# G& H$ u
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);
   8 ?) y3 |% @9 w  W4 Q: t
7. 
   ! u7 Y5 w" S# A1 B: \
8.   /* 检测句柄是否有效 */
     U5 U, P0 ~% v; q2 o* M
9.   if(hjpeg == NULL)
   
10.   {
    3 A3 B* L3 O$ C  `9 j# n' ^% O
11.     return HAL_ERROR;
    
12.   }
    / O  U+ t% ^7 s2 D/ _: s
13. 
    
14.   if(hjpeg->State == HAL_JPEG_STATE_RESET)
    ) R. ^! G( k2 z% G6 q9 D' h+ p; p0 }4 L4 r
15.   {
    
16.     hjpeg->Lock = HAL_UNLOCKED;
    9 w5 J- H3 }; H6 q: `$ Z" B
17. 
    4 _2 F5 X: T; L0 U7 i4 {! |. o
18.      /* 初始化GPIO，NVIC等 */
    
19.     HAL_JPEG_MspInit(hjpeg);
    / A, k( Y; C9 {1 L0 q! U
20.   }
    
21. 
    
22.   /* 设置JPEG状态 */
    
23.   hjpeg->State = HAL_JPEG_STATE_BUSY;
    
24. 
    
25.   /* 使能JPEG  */
    
26.   __HAL_JPEG_ENABLE(hjpeg);
    5 r* n7 C, B/ y
27. 
    
28.   /* 关闭JPEG编解码处理 */
    
29.   hjpeg->Instance->CONFR0 &=  ~JPEG_CONFR0_START;
    
30. 
    / C' c) I5 n4 K
31.   /* 关闭JPEG所有中断 */
    ) [8 k5 J% W3 z8 `& }5 P
32.   __HAL_JPEG_DISABLE_IT(hjpeg,JPEG_INTERRUPT_MASK);
    / Q5 v4 g! _! v9 P- V# _
33. 
    
34.   /* 清空输入输入FIFO缓冲 */
    
35.   hjpeg->Instance->CR |= JPEG_CR_IFF;
    
36.   hjpeg->Instance->CR |= JPEG_CR_OFF;  
      E7 p* O0 L/ G4 t
37. 
    / |/ o5 K' i; m* g, A) B" d
38.   /* 清除所有标志 */
    
39.   __HAL_JPEG_CLEAR_FLAG(hjpeg,JPEG_FLAG_ALL);
    0 K, i7 v* D1 P' |5 q8 r! r
40. 
    
41.   /* 初始化默认的量化表 */
    
42.   hjpeg->QuantTable0 = (uint8_t *)((uint32_t)JPEG_LUM_QuantTable);
    
43.   hjpeg->QuantTable1 = (uint8_t *)((uint32_t)JPEG_CHROM_QuantTable);
    
44.   hjpeg->QuantTable2 = NULL;
    
45.   hjpeg->QuantTable3 = NULL;
    1 {2 T2 l* ^+ t( [: @
46. 
    6 e' O' O) w  ~& }8 }
47.   /* 初始化默认的霍夫曼表 */
    , O% m4 N( p1 [$ u2 U
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)
    
49.   {
    - y$ a# k; h5 C2 T% Y
50.     hjpeg->ErrorCode = HAL_JPEG_ERROR_HUFF_TABLE;
    6 H: O- ^  G0 I/ R2 @' M' E, g
51. 
    
52.     return HAL_ERROR;
    7 M0 \$ N+ Z% H+ T
53.   }
    
54. 
    " a4 G! F( m8 K0 V9 w  Y
55.   /* 使能文件头处理 */
    
56.   hjpeg->Instance->CONFR1 |= JPEG_CONFR1_HDR;
    $ b. }+ J0 d' ?: B+ W/ R
57. 
    
58.   /* 复位JPEG输入输出计数 */
    2 u. C( {- z9 a# ^  `
59.   hjpeg->JpegInCount = 0;
    
60.   hjpeg->JpegOutCount = 0;
    
61. 
    ) X: @! x  `6 S3 ?" y% j' ^* w' e
62.   /* 设置JPEG就绪 */
    $ m4 u" n" S1 `) V! ~* P
63.   hjpeg->State = HAL_JPEG_STATE_READY;
    % l8 S; I6 ?; I. u
64. 
    
65.   /* 设置无错误 Reset the JPEG ErrorCode */
    
66.   hjpeg->ErrorCode = HAL_JPEG_ERROR_NONE;
    0 \  U2 @; o) e# c
67. 
    ( l' d3 a+ {8 r: k7 z' @
68.   /* 清除上下文 */
    
69.   hjpeg->Context = 0;
    $ D$ J8 h0 M* C# u% G
70. 
    1 ?0 u0 f' d# ]/ ^. K5 X! ~* A! e
71.   /* 返回HAL_OK */
    
72.   return HAL_OK;
    3 ^4 P+ F1 r( t$ t( ?
73. }
    - X8 Y/ L4 y. k  q' Q% b4 @
74. 
    % w8 [2 S2 X9 ?+ D. G: O( Q8 I. ]

复制代码

- v1 f# t" m- K. J9 C函数描述：

' o7 q" ^% v& N, W4 y5 U, _' v此函数用于初始化JPEG。
/ ~$ b6 x) P+ F  |8 Y
2 F0 o% Q! I  N$ _: ~函数参数：
+ X. S/ j% g3 H' k
  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
+ e- ]% r9 E! A1 p# N8 s4 C  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
! g2 S- H$ T2 R2 m6 I5 m: Y注意事项：
6 U  X3 B' u: }, d
2 \: u, J: l! A; Z函数HAL_JPEG_MspInit用于初始化JPEG的底层时钟、NVIC等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
3 R9 m" B( v1 W1 |2 W5 f  x; t7 A如果形参hjpeg的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量JPEG_HandleTypeDef JpegHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_JPEG_STATE_RESET  = 0x00U。
  ?* \+ X  \/ F8 Y* I3 ?% r; k
( B! Q1 h: E1 _- p* s7 y解决办法有三
1 k# m  i0 I+ H) w# u- {
, L$ u$ X' p- d% ?方法1：用户自己初始JPEG底层。

方法2：定义JPEG_HandleTypeDef JpegHandle为全局变量。
1 T$ Z$ ]1 f$ }1 o. |, s
& R6 s5 u- v6 N2 W方法3：下面的方法
- c  N% D( L8 o4 e
% n# \! \. G4 z% c6 n% Q

1. if(HAL_JPEG_DeInit(&JpegHandle) != HAL_OK)
   4 h! [* B0 e: D/ K0 u# ^: h, |
2. {
   
3.     Error_Handler();
   0 p( b. D6 ]% d/ {7 U
4. }  
   1 k# m% e+ S4 f* W/ a
5. if(HAL_JPEG_Init(&Dma2dHandle) != HAL_OK)
   ( u! y+ f* r! n. y
6. {
   
7.     Error_Handler();
   
8. }

复制代码

' C0 _6 m! n, s" f5 G使用举例：
) z$ ~+ ~9 P. _2 ^  Z- l5 J3 b

1. JPEG_HandleTypeDef    JPEG_Handle;
   
2. JPEG_Handle.Instance = JPEG;
   ( b! ?  `! d0 r+ W) ?, m8 F/ Q
3. HAL_JPEG_Init(&JPEG_Handle);

复制代码

8 [, S& N* y" G3 Y57.4.2 函数HAL_JPEG_GetInfo
函数原型：

1. HAL_StatusTypeDef HAL_JPEG_GetInfo(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo)
   
2. {
   
3.   uint32_t yblockNb, cBblockNb, cRblockNb;
   4 ~! C4 ?( i) s, W
4. 
   0 {, n( z; U6 t: b. I
5.   /* 检测句柄是否有效 */
   
6.   if((hjpeg == NULL) || (pInfo == NULL))
   
7.   {
   1 A7 A1 {6 w3 ^- N
8.     return HAL_ERROR;
   / b) e. C+ a8 g3 Z9 b. y: V% A5 I
9.   }
   " o, h# D$ }2 n. x$ U/ F
10. 
    8 T: ~6 `3 H: j, W: H
11.   /* 读取配置参数 */
    
12.   if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF_1)
    
13.   {
    $ \$ v5 q9 \. g6 k
14.     pInfo->ColorSpace = JPEG_YCBCR_COLORSPACE;   
    
15.   }   
    4 L/ G1 O7 A: a2 E7 D9 k0 a& z8 i
16.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == 0)
    / c& K# ^$ c/ X8 Z6 U6 W5 ?7 j
17.   {
    
18.     pInfo->ColorSpace = JPEG_GRAYSCALE_COLORSPACE;
    
19.   }
    
20.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF)
    0 e  q- L$ g  \/ ?0 S% f; b
21.   {
    
22.     pInfo->ColorSpace = JPEG_CMYK_COLORSPACE;   
    ! e+ r2 E* b7 m3 @% b* f- H" g
23.   }
    
24. 
    
25.   pInfo->ImageHeight = (hjpeg->Instance->CONFR1 & 0xFFFF0000U) >> 16;
    
26.   pInfo->ImageWidth  = (hjpeg->Instance->CONFR3 & 0xFFFF0000U) >> 16;
    
27. 
    " ^. L9 ?/ r" c4 e
28.   if((pInfo->ColorSpace == JPEG_YCBCR_COLORSPACE) || (pInfo->ColorSpace == JPEG_CMYK_COLORSPACE))
    " G/ b" q4 Q5 O, N
29.   {
    2 z( S. ]" A3 v& }; m& h
30.     yblockNb  = (hjpeg->Instance->CONFR4 & JPEG_CONFR4_NB) >> 4;
    2 L8 }# `4 u3 R  g
31.     cBblockNb = (hjpeg->Instance->CONFR5 & JPEG_CONFR5_NB) >> 4;
    
32.     cRblockNb = (hjpeg->Instance->CONFR6 & JPEG_CONFR6_NB) >> 4;
    5 u( \% n" F$ Q
33. 
    ; T) R" L8 w* u+ K# }
34.     if((yblockNb == 1) && (cBblockNb == 0) && (cRblockNb == 0))
    2 N* y# p! x: B0 J1 d
35.     {
    ( ^  g' M+ J5 ]( K
36.       pInfo->ChromaSubsampling = JPEG_422_SUBSAMPLING; /*16x8 block*/
    
37.     }
    
38.     else if((yblockNb == 0) && (cBblockNb == 0) && (cRblockNb == 0))
    . {! p) r" [# H2 n) j/ g( Q- {: k6 w
39.     {
    4 d$ `+ ?% ]" L) I, m8 `
40.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    
41.     }
    
42.     else if((yblockNb == 3) && (cBblockNb == 0) && (cRblockNb == 0))
    
43.     {
    
44.       pInfo->ChromaSubsampling = JPEG_420_SUBSAMPLING;
    
45.     }
    + l" ^! e) |: o! B" m6 U3 _
46.     else /* 默认是 4:4:4*/
    
47.     {
    
48.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    
49.     }
    
50.   }
    ' u' E9 \" n/ X& v" f& E1 Z
51.   else
    
52.   {
    
53.     pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    3 U) {3 A4 i: L/ l1 l
54.   }
    
55. 
    
56.   pInfo->ImageQuality = JPEG_GetQuality(hjpeg);
    . d/ C2 Q/ i- M; v% g- c
57. 
    
58.   /* 返回HAL_OK */
    
59.   return HAL_OK;
    
60. }
    

复制代码

函数描述：

此函数主要用于解码JPEG时获取相关图像信息，比如图像质量，图像长宽等。

& f: j& d; @5 W3 I  M' U1 C% h# F函数参数：
# y5 C5 Q6 \/ I" @) f
) Z% C, Y0 U& a( T  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是JPEG_ConfTypeDef类型结构体指针变量，用于获取JPEG的配置信息，结构体变量成员的详细介绍看本章3.2小
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。


" [+ x5 @# |% w! l8 \8 I使用举例：

1. JPEG_HandleTypeDef    JPEG_Handle;
   % w  l6 r9 w% ]9 |, J- t
2. JPEG_ConfTypeDef      JPEG_Info;
   , f0 M3 a0 T+ @8 M
3. 
   : O- Z  [* e5 G4 F
4. HAL_JPEG_GetInfo(&JPEG_Handle, &JPEG_Info);  

复制代码

57.4.3 函数HAL_JPEG_Decode_DMA
* }9 K1 N9 }, P4 |* k1 u% R- ^函数原型：

' Z- B4 {& F+ ]: l% I

1. HAL_StatusTypeDef  HAL_JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg ,uint8_t *pDataIn ,uint32_t InDataLength ,uint8_t *pDataOutMCU ,uint32_t OutDataLength)
   2 v& ], y' G% j; Y: x0 X
2. {
   
3.   /* 检测参数 */
     U6 e, h+ j# x- ^8 D, O
4.   assert_param((InDataLength >= 4));
   
5.   assert_param((OutDataLength >= 4));
   
6. 
   
7.   /* 检测参数 */
   
8.   if((hjpeg == NULL) || (pDataIn == NULL) || (pDataOutMCU == NULL))
   & N3 t' p, X  g3 C6 I9 i: W
9.   {
   
10.     return HAL_ERROR;
    
11.   }
    1 m9 J4 V  T! x: a
12. 
    
13.   /* 上锁 */
    0 L" d9 P" A  E* O, o7 @( I; O
14.   __HAL_LOCK(hjpeg);
    
15. 
    ( P9 L! y4 s. b
16.   if(hjpeg->State == HAL_JPEG_STATE_READY)
    ( C) N( T/ G( U$ Y$ ?+ \9 T7 a
17.   {
      P/ X, `2 X, V$ d
18.     /* 设置JPEG忙 */
    
19.     hjpeg->State = HAL_JPEG_STATE_BUSY_DECODING;
    
20. 
    9 N- R# z0 [% C$ D. y
21.     /* 设置JPEG上下文，工作在DMA界面状态 */
    
22.     hjpeg->Context &= ~(JPEG_CONTEXT_OPERATION_MASK | JPEG_CONTEXT_METHOD_MASK);
    # c* ^" F% o2 h1 x- w
23.     hjpeg->Context |= (JPEG_CONTEXT_DECODE | JPEG_CONTEXT_DMA);         
    # O% J5 X0 A- J+ e& S
24. 
    ' N' C/ \4 J! L3 C% L9 W' t( c; g5 C: K; M7 B
25.     /* 设置输入输出缓冲地址和大小 */
    % I: M- Y9 p5 @7 W* u1 s" B
26.     hjpeg->pJpegInBuffPtr = pDataIn;
    
27.     hjpeg->pJpegOutBuffPtr = pDataOutMCU;
    5 t4 }5 r5 Q0 N  W
28.     hjpeg->InDataLength = InDataLength;
    ' M8 W' {$ k* @( x
29.     hjpeg->OutDataLength = OutDataLength;
    6 L; _1 T( o4 l7 O
30. 
    % _) a: W2 _" t, u+ L6 H! L. `
31.     /* 复位输入输出缓冲计数 */
    
32.     hjpeg->JpegInCount = 0;   
    ( ]0 y  @( y& a+ b1 ?/ C8 A! k% R
33.     hjpeg->JpegOutCount = 0;   
    
34. 
    8 \4 ?' f6 i) o. i
35.     /* 初始化解码处理 */
    
36.     JPEG_Init_Process(hjpeg);
    
37. 
    7 X  c4 K# U& }$ p; w
38.     /* 启动JPEG解码处理，使用DMA方式 */
    $ _. j7 j  C# }0 p8 I
39.     JPEG_DMA_StartProcess(hjpeg);
    * N. @+ X" k; H; `9 M% ~
40. 
    
41.   }
    6 K8 F( |6 X) f0 r% r( a
42.   else
    " J! A4 N  }' z: a, E5 H& W6 [% v: A
43.   {
    2 D/ e) b: z% E) [  n7 ^
44.     /* 解锁 */
    ) D% @/ U8 L( n0 t* k& z
45.     __HAL_UNLOCK(hjpeg);
    
46. 
    ( G, c! I) g. X+ {$ @
47.     return HAL_BUSY;
    7 w% Z) G5 T3 c  m. H/ o
48.   }
    ( \5 p/ {* ?: g# V" r" P9 [. n: B
49. 
    
50.   /* 返回HAL_OK */
    
51.   return HAL_OK;
    
52. }
    

复制代码

函数描述：

8 ]6 T1 b* A$ I1 h  ~1 u! c, k此函数用于启动JPEG的DMA方式解码。

函数参数：

1 b/ L, z. _6 j  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是输入数据缓冲地址。
" j! Q: S9 m0 t% K  第3个参数输入数据大小，单位字节。
0 K' w# H' Q( V  第4个参数是输出缓冲地址。
  第5个参数是输出缓冲大小，单位字节。
. Y$ A6 S, f; Q7 f" R# p  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
- {3 X# w1 P2 W, h% c# f
使用举例：

1. /*
   
2. *********************************************************************************************************
   0 u9 r* \4 K* W6 y: L
3. *    函 数 名: JPEG_Decode_DMA
   
4. *    功能说明: JPEG解码
   
5. *    形    参: hjpeg               JPEG_HandleTypeDef句柄指针
   8 E5 V6 A2 Q. d9 d
6. *             FrameSourceAddress  数据地址
   ( H! V( A0 ]1 G; R; N6 L) g" a+ V2 c
7. *             FrameSize           数据大小
   % g) ?* ~' z5 e1 `1 {( r. ~& q7 Y7 I
8. *             DestAddress         目的数据地址
   
9. *    返 回 值: HAL_ERROR表示配置失败，HAL_OK表示配置成功
   
10. *             HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出
    2 D; B9 E& P* n+ E% j/ E
11. *********************************************************************************************************
    3 |. t1 J3 _1 c. u: j* d* O
12. */
    
13. uint32_t JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg, uint32_t FrameSourceAddress ,uint32_t FrameSize, uint32_t DestAddress)
    7 U9 _( N, ]8 o& F* ]$ ^$ b0 r
14. {
    $ R3 |# o5 N5 O! v& t  j" G; q
15.     JPEGSourceAddress =  FrameSourceAddress ;
    6 s7 r8 R4 w9 y- J
16.     FrameBufferAddress = DestAddress;
    
17.     Input_frameIndex = 0;
    
18.     Input_frameSize = FrameSize;
    
19. 
    % ^3 t% U/ ]9 u) w& x
20.     /* 设置标志，0表示开始解码，1表示解码完成 */
    . f1 J% _: p$ k( I) U
21.     Jpeg_HWDecodingEnd = 0;
    - A( y" }2 H7 f6 T6 ]8 X  v. u+ }+ v
22. 
    
23.     /* 启动JPEG解码 */
    
24.     HAL_JPEG_Decode_DMA(hjpeg ,(uint8_t *)JPEGSourceAddress ,CHUNK_SIZE_IN ,
    
25. (uint8_t *)FrameBufferAddress ,CHUNK_SIZE_OUT);
    2 W" `0 v+ F  l& k5 u
26. 
    
27.     return HAL_OK;
    
28. }

复制代码

57.4.4 函数HAL_JPEG_ConfigInputBuffer
' p& y" y( T2 _% T" s/ S9 p  i- l函数原型：

! U6 c6 [% y! ^8 T

1. void HAL_JPEG_ConfigInputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewInputBuffer, uint32_t InDataLength)
   
2. {
   
3.   hjpeg->pJpegInBuffPtr =  pNewInputBuffer;
   7 K$ M! ]3 P: l9 X# v8 \
4.   hjpeg->InDataLength = InDataLength;
   & Z% v7 J1 J0 F( o: K" _* Y# P
5. }

复制代码

8 e" V: P. q. `2 X* d函数描述：

- u3 F9 t, ]' `1 S此函数用于配置编解码输入缓冲地址和数据大小。
6 G/ v  {5 _! [- m8 F
: r; O# T+ u, O2 o; D函数参数：
) \$ L5 v6 g! K9 J
6 M( @/ A/ j! W5 Z# c; }- b" ?  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
% x' K( \1 j' r: C2 w  第2个参数是输入缓冲地址。
5 Q& ?" z2 V4 {. o8 q% A& O  第3个参数是输入缓冲大小，单位字节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
% o% x+ s$ A3 B! Q; H$ m9 v. e使用举例：
, n+ P( {6 b: Q: N# f+ @1 u" P. X
/ D- q( V$ S3 F& P

1. /*
   
2. *********************************************************************************************************
   / N; M/ d. p! x$ Q  Q& a; e
3. *    函 数 名: HAL_JPEG_GetDataCallback
   5 o# l. q" ]6 J" M! i3 m. @/ C
4. *    功能说明: JPEG回调函数，用于从输入地址获取新数据继续解码
   & P3 x! W0 X+ g
5. *    形    参: hjpeg          JPEG_HandleTypeDef 句柄指针
   
6. *             NbDecodedData  上一轮已经解码的数据大小，单位字节  
   
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void HAL_JPEG_GetDataCallback(JPEG_HandleTypeDef *hjpeg, uint32_t NbDecodedData)
    
11. {
    
12.     uint32_t inDataLength;
    : x$ Q% \! J+ [
13. 
    
14.     /* 更新已经解码的数据大小 */
    3 ~0 a( i! ~1 A! O2 ^# H- S* E2 T* S  a
15.     Input_frameIndex += NbDecodedData;
    5 R& i- |4 C% O  s0 o9 t
16. 
    ' Z0 R* p* ^/ M3 a0 `/ Y
17.     /* 如果当前已经解码的数据小于总文件大小，继续解码 */
    $ o; E  `" S3 C  _9 K
18.     if( Input_frameIndex < Input_frameSize)
    
19.     {
    
20.         /* 更新解码数据位置 */
    8 t4 W& ~' w5 @6 G
21.         JPEGSourceAddress = JPEGSourceAddress + NbDecodedData;
    
22. 
    - ]$ \  L* A9 Q5 _  S2 F" y8 F3 Y
23.         /* 更新下一轮要解码的数据大小 */
    
24.         if((Input_frameSize - Input_frameIndex) >= CHUNK_SIZE_IN)
    
25.         {
    9 u+ ?, v3 K3 F; f
26.             inDataLength = CHUNK_SIZE_IN;
    + J5 g9 K1 m0 Y
27.         }
    " {5 s+ q* j+ |( |, z1 q& W/ d' Q: G
28.         else
    / h! P- c' l) U7 f3 i* }
29.         {
    3 U6 R# Z6 }! F, r: i+ u
30.             inDataLength = Input_frameSize - Input_frameIndex;
    , p; V# x4 c7 u- M
31.         }   
    " F4 R/ ]1 j  ^; v
32.     }
    - k) s7 ~2 u; ^; v4 j* Z3 I: M  ?
33.     else
    
34.     {
    
35.         inDataLength = 0;
    
36.     }
    ' f# q5 [" ^/ H0 b( {' p
37. 
    
38.     /* 更新输入缓冲 */
    
39.     HAL_JPEG_ConfigInputBuffer(hjpeg,(uint8_t *)JPEGSourceAddress, inDataLength);   
    # s# i; Z# A9 s5 ^0 n
40. }

复制代码

% g7 s8 g4 p" t! P) g
' j9 @+ S( `8 h8 J+ M3 z57.4.5 函数HAL_JPEG_ConfigOutputBuffer
函数原型：

/ ~  z9 o. r+ A- P2 [5 h  M  z

1. void HAL_JPEG_ConfigOutputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewOutputBuffer, uint32_t OutDataLength)
   
2. {
   9 b0 x4 G0 s8 N1 o
3.   hjpeg->pJpegOutBuffPtr = pNewOutputBuffer;
   * Q/ }8 A5 w* q, P( U" @
4.   hjpeg->OutDataLength = OutDataLength;  
   ; f' x3 Z0 ]% B4 j3 }
5. }

复制代码

# p" s: [% C5 O, J1 e
函数描述：

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

0 t% B  b5 n1 v1 W5 X函数参数：

  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是输出缓冲地址。
  第3个参数是输出缓冲大小，单位字节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
! N# b: i7 ?5 Z& p  U8 ~使用举例：

# x; j, S$ |1 Y3 G9 \, n5 k* ~

1. /*
   
2. *********************************************************************************************************
   8 E# A4 y5 Q3 m$ i2 N# c
3. *    函 数 名: HAL_JPEG_DataReadyCallback
   
4. *    功能说明: JPEG回调函数，用于输出缓冲地址更新
   
5. *    形    参: hjpeg         JPEG_HandleTypeDef 句柄指针
   
6. *             pDataOut      输出数据缓冲
   ) ~5 m/ s+ X/ s2 X9 `
7. *             OutDataLength 输出数据大小，单位字节
   * \% \' P3 O' M2 o0 n8 w
8. *    返 回 值: 无
   
9. *********************************************************************************************************
     O/ j* t. I# A3 g0 t: u
10. */
    
11. void HAL_JPEG_DataReadyCallback (JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, uint32_t OutDataLength)
    
12. {
    5 j! w; q7 J3 |" M
13.     /* 更新JPEG输出地址 */  
    + j# X# [0 Q# z, K% d8 A
14.     FrameBufferAddress += OutDataLength;
    1 l! {  m9 y) F: ^% X
15. 
    # G8 }8 c- K; n3 ?4 h& G
16.     HAL_JPEG_ConfigOutputBuffer(hjpeg, (uint8_t *)FrameBufferAddress, CHUNK_SIZE_OUT);
    : q* z& w  w" p8 Z  ]
17. }

复制代码

( ]* D+ D+ o" D0 q) \57.5 总结
6 S* j$ d$ D9 C" d1 ?本章节就为大家讲解这么多，JPEG功能用到的地方还是比较多的，建议熟练使用。

' R* w7 \' G; a6 ]( W8 O
  b5 a2 D2 X: P# |  t# [% v
! a5 m2 r0 P2 d# H