57.1 初学者重要提示
* i$ }& w0 o5 n  由于硬件JPEG解码后输出的图像格式是YCbCr，所以本章对YCbCr进行了重点介绍。
  测试STM32H7硬件JPEG解码800*480图片性能，全部通过SDRAM缓存数据，解码10ms，显示9ms。
  JPEG涉及到的知识点还是比较多的，如果想深入了解JPEG的话，可以看本章2.6小节给的参考资料。
4 t' `7 p0 i( M8 b  本章JPEG相关概念的介绍参考了wiki百科和百度百科。
57.2 硬件JPEG基础知识
, c6 b$ W3 P1 h: j% P: }! u' @0 ?对于STM32H7的硬件JPEG了解到以下几点即可：

  支持JPEG解码和编码。
$ ]& U* `- Z7 P5 q. o7 W: L" B, @  对每个像素数据进行编解码只需一个时钟周期。
  支持RGB、 YCbCr、YCMK和BW（灰度）图像色彩模型。
  编解码时每图像分量8位深度。
# u( Y2 A: j0 d% ~
57.2.1 JPEG硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速地了解JPEG的基本功能，然后再看手册了解细节。框图如下所示：
0 C1 O% P% r& ^5 M- d, P
9 X2 G! ^# z! ^' f; t, V- n$ _

! T- K" w* ?" ]! i& G6 m  V
, p4 ^" M  m& A0 G" o通过这个框图，我们可以得到如下信息：
9 n/ Q% I8 O6 E% ~5 c
# T/ W2 l$ X* h  JPEG硬件外设支持编码和解码
并且对于输入数据和输出数据都有FIFO支持。

$ E. [! r5 ]1 O) u. ~' T: S  jpeg_hclk
为JPEG内核和寄存器提供时钟。

4 i5 a9 O- Y2 @8 A1 ?& Y  jpeg_it
9 f. K* W# U: L8 `: yJPEG全局中断输出。
9 z: R" p3 W# h3 b) N
  jpeg_ift_trg
JPEG输入FIFO阈值信号，可触发MDMA。
' k4 I5 `9 x7 }! a+ [6 [( g- @
  jpeg_ifnf_trg
JPEG输入FIFO未满信号，可触发MDMA。
. a+ W3 ?1 N9 |" q& \
4 Q. j5 w+ T+ M5 u8 T& d$ w  jpeg_oft_trg
JPEG输出FIFO阀值信号，可触发MDMA。

  jpeg_ofne_trg
! U, ?- m+ h) O( }2 c9 G) s2 Z& [% [JPEG输出FIFO非空信号，可触发MDMA。
( q1 W8 e) @5 g
  jpeg_oec_trg
  k/ W5 R7 M" n8 tJPEG转换结束信号，可触发MDMA。
* Y4 x2 ?4 r* P, V! Z; P
2 {% N8 K0 `! n0 S) s57.2.2 YCbCr颜色格式
" \4 Y2 Z9 E4 H, t6 s+ e（注，硬件JPEG解码后输出的图像格式是YCbCr，所以有必要了解下）

1 ^: q, u" @; v' f: \' w正如几何上用坐标空间来描述坐标集，而色彩空间用数学方式来描述颜色集。常见的3种色彩模型是RGB，CMYK和YUV。
- T& S& |$ M: {4 h& Q! ]3 _3 m
: e5 U3 n' d4 k8 y/ TYCbCr是YUV经过缩放和修改的翻版，只是在表示方法上不同。其中Y是指亮度分量，Cb指蓝色色度分量，而Cr指红色色度分量。人眼对视频的Y分量更敏感，因此通过对色度分量进行子采样来减少色度分量后，人眼察觉不到的图像质量的变化。
/ ?& Q; N2 y# b$ v& a
! f' K- f% M* h9 B在YUV 家族中，YCbCr 是在计算机系统中应用最多的成员，其应用领域广泛，JPEG、MPEG均采用此格式。一般人们所讲的YUV大多是指YCbCr。
2 c" N* X) s  H6 [1 G/ p
9 a+ }5 B2 {8 S3 l0 h& B1 w5 u* i57.2.3 YCbCr采样格式
YCbCr有许多取样格式，如YCbCr 4:4:4，YCbCr 4:2:2，YCbCr 4:1:1 和YCbCr 4:2:0。
; R+ s' Y4 F" d% w. [
3 y, h2 b3 N8 X; j8 P& u  4:2:0
2 Y) ~0 N2 u( a- P7 I+ W9 ^" O& A' S表示每4个像素有4个亮度分量，2个色度分量 (YYYYCbCr），仅采样奇数扫描线，是便携式视频设备（MPEG-4）以及电视会议（H.263）最常用格式。
# Q  V  Y$ s& j9 A$ L! h+ I% g
9 X6 Z+ h7 X9 u* N  4:2:2
1 d7 y% P5 w/ G, E表示每4个像素有4个亮度分量，4个色度分量（YYYYCbCrCbCr），是DVD、数字电视、HDTV以及其它消费类视频设备的最常用格式。
* ?3 B% y2 ~+ R  d+ C3 h
2 l3 A5 b$ o* D  4:4:4
% D3 G& `, e5 B5 k) |- R8 o8 D表示全像素点阵(YYYYCbCrCbCrCbCrCbCr），用于高质量视频应用、演播室以及专业视频产品。

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

1 b' _, L8 ]6 }$ G( Y# M
+ m# b( j2 H3 t! ]  u/ `5 q  z由上面的截图可以了解到：
7 i, [2 R; }4 y, `& P
0 h0 Y' w' o4 j& t( U& S0 R4:4:4表示Y通道，Cb+Cr通道全部采样。

4:2:2表示Y通道全部采样，而Cb+Cr通道两个像素为一组，统一采用第1个颜色值。

5 `+ z; {# S( O0 N' r4:2:0表示Y通道全部采样，而Cb+Cr通道四个像素为一组，统一采用第1个颜色值。
& ^: @/ g+ F) m6 a
下面是整体效果，方便大家更好的理解：
0 l: |! p; S1 l8 X& F; X

( Z8 w$ K; r1 c) j1 Y


57.2.4 YCbCr的优势
5 M' F9 R  _* e" `& g* E: ORGB信号作为存储和传输的效率不高，因为它们具有大量冗余信息。而使用YCbCr可以丢弃一些信息以减少带宽，因为人的肉眼对视频的Y分量更敏感，因此通过对色度分量进行子采样来减少色度分量后，肉眼察觉不到的图像质量的变化。了解这种人为缺点，NTSC和PAL等标准大大降低了色度通道的带宽。
: ~3 b/ f9 \0 R2 b
57.2.5 YCbCr和RGB互转
) E3 k' H% U1 u为了方便大家更好的了解YCbCr和RGB图像的实际效果，特此搜集整理了两个截图（来自WIKI百科）。下面是图像转YCBCR的效果：四个图，从上到下依次是原始图像，Y通道，Cb通道和Cr通道。
. y3 I& g0 C+ i

- x- l+ ^/ M5 f+ J- ]
: C9 P/ W% p" R6 F8 V下面是一幅图像分别以R，G，B通道和Y，CB，CR通道的方式展示：
6 ?  l( f0 C  ~" D4 I5 _4 c6 j
# |$ }! a8 b  H2 P5 L* ^

& j% k2 P) x1 f- X0 n) B
6 ?8 k0 n! B1 f& Y8 A! Q& o57.2.6 JPEG编解码知识
JPEG涉及到的知识点比较多，这里有之前整理的20多个专题知识点，大家有兴趣可以了解下（不了解也没有关系，不影响使用硬件JPEG外设）

57.3 硬件JPEG的HAL库用法
6 M. Q. k; P' E) ]- c5 B, ^8 G1 w# fJPEG的HAL库用法其实就是几个结构体变量成员的配置和使用，然后配置时钟，并根据需要配置NVIC、中断和MDMA。下面我们逐一展开为大家做个说明。

+ b7 o% G' R8 e) h( P1 U6 B/ [57.3.1 JPEG寄存器结构体JPEG_TypeDef
JPEG相关的寄存器是通过HAL库中的结构体JPEG_TypeDef定义的，在stm32h743xx.h中可以找到它们的具体定义：
% L. `6 s6 J5 r4 d. V

1. typedef struct
   
2. {
   
3.   __IO uint32_t CONFR0;         
   
4.   __IO uint32_t CONFR1;         
   
5.   __IO uint32_t CONFR2;        
   * M8 n7 H5 U( j/ Z+ O
6.   __IO uint32_t CONFR3;        
   3 J$ j$ f9 M  e& t! c
7.   __IO uint32_t CONFR4;         
   / K" M- q- N. o1 o- U
8.   __IO uint32_t CONFR5;      
   
9.   __IO uint32_t CONFR6;      
   
10.   __IO uint32_t CONFR7;        
    
11.   uint32_t  Reserved20[4];      
    
12.   __IO uint32_t CR;            
    
13.   __IO uint32_t SR;            
    
14.   __IO uint32_t CFR;            
    ( o; g. {/ B3 I+ V  K
15.   uint32_t  Reserved3c;        
    
16.   __IO uint32_t DIR;         
    $ S! w  K- n4 U5 P2 p) C3 I4 E3 k- U
17.   __IO uint32_t DOR;            
    
18.   uint32_t  Reserved48[2];      
    
19.   __IO uint32_t QMEM0[16];     
    
20.   __IO uint32_t QMEM1[16];      
    $ ~+ N' b1 F2 q# ]+ E+ v
21.   __IO uint32_t QMEM2[16];      
    
22.   __IO uint32_t QMEM3[16];      
    
23.   __IO uint32_t HUFFMIN[16];   
    . E" \5 B; Q  @2 i
24.   __IO uint32_t HUFFBASE[32];   
    
25.   __IO uint32_t HUFFSYMB[84];   
    3 j. B& h" C( R' [
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];  
    
31.   __IO uint32_t HUFFENC_DC1[8];
    
32. } JPEG_TypeDef;

复制代码

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

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   3 d1 d! d; i- t, V' R. B
2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */

复制代码

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

1. #define PERIPH_BASE           ((uint32_t)0x40000000)
   3 q& u- T  Y+ K% b1 p' b
2. #define D1_AHB1PERIPH_BASE    (PERIPH_BASE + 0x12000000)
   
3. #define JPEG                  ((JPEG_TypeDef *) JPGDEC_BASE)
   
4. #define JPGDEC_BASE           (D1_AHB1PERIPH_BASE + 0x3000) <----- 展开这个宏，(JPEG_TypeDef *) 0x52003000

复制代码

$ L/ o7 I+ [3 A我们访问JPEG的CR寄存器可以采用这种形式：JPEG->CR = 0。

57.3.2 JPEG的编解码参数结构体JPEG_ConfTypeDef
0 A! c6 Z! X2 d此结构体用于JPEG的编解码参数，具体定义如下：

7 l) a2 q" n5 I; I0 C1 W* t, ?

1. typedef struct
   9 U7 C8 M! e2 K* U7 S! I6 B( q
2. {
   
3.   uint8_t  ColorSpace;               
   / S  L# f" D/ c* [. y
4.   uint8_t  ChromaSubsampling;        
   3 C" ~& L" f3 G' Z1 R" u/ ]+ P
5.   uint32_t ImageHeight;              
   ' p) J3 U+ N% ~$ T7 F2 q1 W
6.   uint32_t ImageWidth;            
   
7.   uint8_t  ImageQuality;               
   
8. }JPEG_ConfTypeDef;

复制代码

下面将这几个参数逐一为大家做个说明：
, a- Y6 P2 {3 i2 ^  uint8_t  ColorSpace

; x+ i6 F4 \9 x# _
$ `3 R1 g0 {$ ]5 x, L  U) l此参数用于设置输出数据流中的量化表，具体支持的参数如下：

1. #define JPEG_GRAYSCALE_COLORSPACE     ((uint32_t)0x00000000U)    /* 灰度（1 个量化表）*/
   % ?5 t; }" _! Z& t' _) T
2. #define JPEG_YCBCR_COLORSPACE         JPEG_CONFR1_COLORSPACE_0   /* YUV（2 个量化表） */
   4 R5 P4 @2 }4 }
3. #define JPEG_CMYK_COLORSPACE          JPEG_CONFR1_COLORSPACE     /* CMYK（4 个量化表）*/

复制代码

  uint8_t  ChromaSubsampling
此参数用于色度子采样，具体支持的参数如下：
3 o- d( Z3 K5 z6 ?  `( N( E: |

1. #define JPEG_444_SUBSAMPLING     ((uint32_t)0x00000000U)   /* 4:4:4 */
   ' m9 g# A' {* _, ^! v5 B
2. #define JPEG_420_SUBSAMPLING     ((uint32_t)0x00000001U)   /* 4:2:0 */
   
3. #define JPEG_422_SUBSAMPLING     ((uint32_t)0x00000002U)   /* 4:2:2 */

复制代码

  uint32_t  ImageHeight
此参数用于图像高度。

  D5 e" g8 }* [2 q9 T& w  uint32_t ImageWidth
此参数用于图像宽度。
" Y  }* N) D* {5 Y
  uint8_t  ImageQuality
此参数用于图像质量，参数范围1 – 100，1最差，100最好。
* Y/ q$ k7 c( {" L: t: @" B
57.3.3 JPEG结构体句柄JPEG_HandleTypeDef
, F* x3 w4 i$ q; @# t# y' m  T5 y$ z+ E& ~HAL库在JPEG_TypeDef， JPEG_ConfTypeDef的基础上封装了一个结构体JPEG_HandleTypeDef，定义如下：
. E$ w2 U  ]* H/ f- J% g
# A' q5 ]& g; U( p9 t9 O0 F  W

1. typedef struct
   
2. {
   - i4 W7 S, `+ i0 O2 z+ C* h0 Z. J2 F
3.   JPEG_TypeDef             *Instance;        
   
4.   JPEG_ConfTypeDef         Conf;            
   
5.   uint8_t                  *pJpegInBuffPtr;
   1 M2 `6 n  v2 `: {
6.   uint8_t                  *pJpegOutBuffPtr;
   ! j. `' T0 N2 N3 ~) k
7.   __IO uint32_t            JpegInCount;      
   
8.   __IO uint32_t            JpegOutCount;     
   * Z6 X9 A* W4 B8 u6 ]( Z
9.   uint32_t                 InDataLength;     
   
10.   uint32_t                 OutDataLength;     
    
11.   MDMA_HandleTypeDef        *hdmain;         
    
12.   MDMA_HandleTypeDef        *hdmaout;        
    ! S/ ~/ e: @6 p, D& a. w; E
13.   uint8_t                  CustomQuanTable;
    & y: v; Y) c$ A9 l9 o- m0 A0 L
14.   uint8_t                  *QuantTable0;   
    ' H0 |" W, i% L, c
15.   uint8_t                  *QuantTable1;   
    
16.   uint8_t                  *QuantTable2;   
    
17.   uint8_t                  *QuantTable3;         
    " G" [0 ?! i, ^' c1 Y7 X$ k( z4 g
18.   HAL_LockTypeDef          Lock;            
    
19.   __IO  HAL_JPEG_STATETypeDef State;         
    / N" C9 N8 F. R* k) m; Y3 x5 L
20.   __IO  uint32_t           ErrorCode;      
    
21.   __IO uint32_t Context;                    
    # _4 W% M! L7 t$ x0 w0 ?8 g1 j
22. }JPEG_HandleTypeDef;

复制代码

, Q* c8 S% U- U1 N% a下面将这几个参数逐一做个说明。
4 ?: f/ u' A  B+ T: T2 q- ~
  JPEG_TypeDef   *Instance
( q7 F& l3 Q0 b; A+ Q这个参数是寄存器的例化，方便操作寄存器，详见本章3.1小节。

# B; X- E$ T3 \+ g% H0 L! }/ b  JPEG_ConfTypeDef   Conf
这个参数是用户接触较多的，用于JPEG的编解码参数，详见本章3.2小节。

# M  @; k; D6 K# ]/ [  uint8_t       *pJpegInBuffPtr
6 G! I, b3 z# L1 {$ SJPEG编解码输入缓冲地址
/ o) H1 a- Y  h
. q' N7 x( |" h9 A% `8 V1 e; W  uint8_t       *pJpegOutBuffPtr
JPEG编解码输出缓冲地址
! W, S7 W6 i3 B2 f
( o+ F# U! i5 }  Q7 e1 T  __IO uint32_t   JpegInCount
JPEG内部输入计数。
8 C; u) y. d3 a
, b0 a( U" x$ ]  __IO uint32_t   JpegOutCount
JPEG内部输出计数。
6 D0 @5 w5 q: b. g% B
  uint32_t        InDataLength
JPEG输入缓冲区长度，单位字节

* u( ~% N; N* D+ O% p( u8 A* R, B$ h6 U  uint32_t          OutDataLength
JPEG输出缓冲区长度，单位字节。
' I! V2 z1 E0 |* r  p
  MDMA_HandleTypeDef        *hdmain
% L. x( Q, x: b8 U+ Y9 ?5 ^  MDMA_HandleTypeDef        *hdmaout
/ |* G$ H. W$ e1 FMDMA句柄结构体指针变量，用于关联JPEG句柄，方便调用。
  n+ H3 q5 a4 a) R" E
  uint8_t       CustomQuanTable
5 M. ^3 F7 {( m7 G如果此参数设置为1，将使用用户设置的量化表。
4 R4 P- Y# F4 S8 T2 a  _
  uint8_t      *QuantTable0;   
  uint8_t      *QuantTable1;     
  uint8_t      *QuantTable2;   
  uint8_t      *QuantTable3;
指定量化表地址。   
3 r& u' Z! k+ ?! _1 F) U2 d
  HAL_LockTypeDef          Lock           
  __IO  HAL_JPEG_STATETypeDef State           
  __IO  uint32_t           ErrorCode      
这三个变量主要供函数内部使用。Lock用于设置锁状态，State用于设置JPEG状态，而ErrorCode用于配置代码错误。

  __IO uint32_t Context
/ ^6 y3 Q1 n5 }9 \, \JPEG上下文。
9 L1 P0 f; @( F+ W  W! k1 f
57.3.4 JPEG初始化流程总结
$ D0 Z+ N' t: r" ~' ]使用方法由HAL库提供：

  第1步：调用函数HAL_JPEG_Init进行初始化，但这个函数不需要初始化参数。

如果是JPEG编码，可以通过函数HAL_JPEG_ConfigEncoding设置JPEG图像的质量参数，质量越高，生成的JPEG文件越大、

+ G0 U7 {$ {* E3 k" s" K  第2步：调用编解码函数
, u% @* S- N/ }; w% ~: ^; X9 }
) F3 @1 d5 E3 G+ D3 ~' I- U  查询式编解码函数
HAL_JPEG_Encode
/ C; f  y5 G9 z
HAL_JPEG_Decode
1 ^, Z% c+ V$ v+ [* }1 k+ d2 \


3 W: s# B% m6 ]+ A4 h  中断方式
5 f9 O4 j6 X9 jHAL_JPEG_Encode_IT
8 d" z4 X- A5 D# Z% Q/ d5 o
. s7 z0 x, u. wHAL_JPEG_Decode_IT
- n/ S% j5 Y4 ]) {/ Y3 f5 r
6 m0 Y: [% K2 u& u% @! x

4 l3 l) n0 N: ~$ P6 k' k4 s  DMA方式
( N- f! w- B/ v" |) f) S$ k( U+ BHAL_JPEG_Encode_DMA

HAL_JPEG_Decode_DMA
+ V0 i) B3 H. j4 b: \! i
  第4步：如果用户之前的数据已经处理完毕，需要插入新数据，会调用函数HAL_JPEG_GetDataCallback
3 T5 e/ ~  ?6 K! [7 M
% |$ I- X  H3 C9 N" y（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里面被调用的）。
4 S* G$ y  }- Y3 t

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

, T8 W  S8 F2 F  k
$ O$ h* k0 Z1 h5 y, ^. `（3）新的数据块准备好后，可以在回调函数HAL_JPEG_GetDataCallback外面调用HAL_JPEG_ConfigInputBuffer 和 HAL_JPEG_Resume，但是为了保持数据一致性问题，务必在回调函数HAL_JPEG_GetDataCallback里面调用HAL_JPEG_Resume。
- e1 a* Q' E4 h% A4 p/ c
) B9 U+ u9 Y) C$ o1 a) F! ?/ T" }
7 ~  h9 J( L! h. v4 N) }7 [  第5步：输出缓冲区填充了给定大小的数据后，会调用回调函数HAL_JPEG_DataReadyCallback

; d* _; a  s% K- C  K（1）如果有数据空间存储新数据块，需要调用函数HAL_JPEG_ConfigOutputBuffer配置新存储位置。如果没有数据空间存储新数据块，需要等待有数据空间可用时，可以调用函数HAL_JPEG_Pause（参数XferSelection被设置为JPEG_PAUSE_RESUME_INPUT），待有数据空间可用时，可以调用HAL_JPEG_ConfigOutputBuffe设置新的输出缓冲，然后调用函数HAL_JPEG_Resume恢复JPEG编解码。
; `3 x0 x# B% i; C4 W% c
（2）函数HAL_JPEG_ConfigOutputBuffe/HAL_JPEG_Pause/HAL_JPEG_Resume的工作机制允许应用程序以块为单位接收数据。当接收到数据块时，应用程序可以暂停JPEG输出来处理这些数据，比如解码时YCbCr转RGB或者编码时数据存储。
. {1 p# c, u  N; f& X
（3）新的数据空间准备好后，可以在回调函数HAL_JPEG_DataReadyCallback外面调用HAL_JPEG_ConfigOutputBuffer和 HAL_JPEG_Resume，但是为了保持数据一致性问题，务必在回调函数HAL_JPEG_DataReadyCallback里面调用HAL_JPEG_Resume。


  第6步：其它相关函数

  JPEG解码时，如果解码成功，会调用回调函数HAL_JPEG_InfoReadyCallback。
  JPEG编码操作结束后会调用回调函数HAL_JPEG_EncodeCpltCallback。
  JPEG解码操作结束后，会调用回调函数HAL_JPEG_DecodeCpltCallback。
+ B& @. i# j" m3 I8 b  操作过程中出现错误，会调用回调函数HAL_JPEG_ErrorCallback，用户可以调用函数HAL_JPEG_GetError获取错误类型。
  HAL JPEG默认使用的是ISO/IEC 10918-1规格量化表，如果要修改，可以调用函数HAL_JPEG_SetUserQuantTables实现。
; e+ y$ O; W6 X; ~  通过函数HAL_JPEG_GetState可以获取JPEG状态。
3 e3 {3 M, ]/ G; v2 G3 Q8 Z# _

57.4 源文件stm32h7xx_hal_jpeg.c
$ p1 }/ l8 h/ r1 H$ `这里把我们把如下几个常用到的函数做个说明：

* g! i4 o$ @% P, o& B! f4 C* p% b  HAL_JPEG_Init
3 l7 w! c  Z, F9 D5 M6 P8 a9 n  v  HAL_JPEG_GetInfo
  HAL_JPEG_Decode_DMA
( `0 z% I. E8 U0 d  HAL_JPEG_ConfigInputBuffer
  HAL_JPEG_ConfigOutputBuffer
- q' l- g* i/ S0 o2 U+ d3 G2 y
  X, L7 _  t( l' ]7 [57.4.1 函数HAL_JPEG_Init
4 o/ @( L0 ]( T) c" \函数原型：

4 ^% H# s0 d( ^8 d0 _9 U6 x

1. HAL_StatusTypeDef HAL_JPEG_Init(JPEG_HandleTypeDef *hjpeg)
   
2. {
   3 M* c+ e# G& I; T& x% h* i
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);
   , O" u! G6 W9 ~  P7 A
6.   uint32_t dcChrom_huffmanTableAddr = (uint32_t)(&JPEG_DCCHROM_HuffTable);
   
7. 
   
8.   /* 检测句柄是否有效 */
   + V- e" V1 i( z0 B/ ~2 d" {
9.   if(hjpeg == NULL)
   
10.   {
    
11.     return HAL_ERROR;
    2 Y0 u- q* C  ^9 x) H9 ^* U
12.   }
    + u8 D  w6 i+ B9 ], X" D
13. 
    
14.   if(hjpeg->State == HAL_JPEG_STATE_RESET)
    5 c" k4 {. e; [+ a' w
15.   {
    
16.     hjpeg->Lock = HAL_UNLOCKED;
    1 K/ [; ^5 V+ z2 `# B
17. 
    
18.      /* 初始化GPIO，NVIC等 */
    
19.     HAL_JPEG_MspInit(hjpeg);
    ( Q& ^* g/ J8 z5 i8 [$ M9 ?
20.   }
    * }3 q" q3 Y; y
21. 
    
22.   /* 设置JPEG状态 */
    
23.   hjpeg->State = HAL_JPEG_STATE_BUSY;
    : R; `5 |; u7 u8 _7 {% e) y' M
24. 
    
25.   /* 使能JPEG  */
    3 R1 a) v$ |% g6 X' a7 k
26.   __HAL_JPEG_ENABLE(hjpeg);
    / M. w1 z; ^) q7 O0 Q" ?$ \+ s
27. 
    3 J  c3 n  k7 D' Y
28.   /* 关闭JPEG编解码处理 */
    
29.   hjpeg->Instance->CONFR0 &=  ~JPEG_CONFR0_START;
    
30. 
    
31.   /* 关闭JPEG所有中断 */
    " X, }! L( q9 S1 f8 _( l) I% b
32.   __HAL_JPEG_DISABLE_IT(hjpeg,JPEG_INTERRUPT_MASK);
    
33. 
    6 I8 ^8 S9 [$ W
34.   /* 清空输入输入FIFO缓冲 */
    
35.   hjpeg->Instance->CR |= JPEG_CR_IFF;
    8 ^5 @( R  ]) u2 Q; \0 r
36.   hjpeg->Instance->CR |= JPEG_CR_OFF;  
    9 V3 d1 O" n9 Z+ ?; N* ]6 A9 j
37. 
    ! r& E0 t- x1 f
38.   /* 清除所有标志 */
    
39.   __HAL_JPEG_CLEAR_FLAG(hjpeg,JPEG_FLAG_ALL);
    
40. 
    
41.   /* 初始化默认的量化表 */
    5 Z  I% n! _$ _) B
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;
    $ `! @  D3 l/ e8 i1 l# i# t4 D
46. 
    9 {. Y. t' Z' d! D" Q  y
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)
    # M9 N4 |- V6 U) I4 Z
49.   {
    ( u) ?( b) h2 B& H3 {5 E
50.     hjpeg->ErrorCode = HAL_JPEG_ERROR_HUFF_TABLE;
    4 a( m# @4 k3 ~' `
51. 
    ' `" K& @% q# w0 p+ w  k
52.     return HAL_ERROR;
    
53.   }
    
54. 
    2 y7 ^- w6 e* e+ s
55.   /* 使能文件头处理 */
    & D2 Z6 t, U8 k8 o* ~
56.   hjpeg->Instance->CONFR1 |= JPEG_CONFR1_HDR;
    
57. 
    % h9 E) k9 i  N) z9 f# c2 M/ j
58.   /* 复位JPEG输入输出计数 */
    6 b' h% _. n; c: }# P
59.   hjpeg->JpegInCount = 0;
    & o, T5 f  U$ G0 k2 `! z9 n0 @9 @
60.   hjpeg->JpegOutCount = 0;
    
61. 
    * ~& e% P$ s% Y3 N$ G
62.   /* 设置JPEG就绪 */
    ' Z* N9 v2 x2 f9 @1 m3 {/ |
63.   hjpeg->State = HAL_JPEG_STATE_READY;
    
64. 
    * H7 R7 N# C- I6 f- i7 P. E# Q/ u2 U
65.   /* 设置无错误 Reset the JPEG ErrorCode */
    
66.   hjpeg->ErrorCode = HAL_JPEG_ERROR_NONE;
    
67. 
    
68.   /* 清除上下文 */
    
69.   hjpeg->Context = 0;
    
70. 
    
71.   /* 返回HAL_OK */
    ; M% E+ W) T3 W, {( `9 [/ w
72.   return HAL_OK;
    7 H. y/ p5 E/ u
73. }
    
74. 
    

复制代码

函数描述：

此函数用于初始化JPEG。

3 J% x; u. X3 V0 J1 Y" f函数参数：

  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
1 @& n1 J5 U& K6 _& B9 G& {  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
注意事项：
- n) M$ u6 K! J9 n
函数HAL_JPEG_MspInit用于初始化JPEG的底层时钟、NVIC等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参hjpeg的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量JPEG_HandleTypeDef JpegHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_JPEG_STATE_RESET  = 0x00U。

2 Y* I$ k1 {( D$ y: v' N7 H解决办法有三
; E9 A4 s7 A* R/ z2 S( s5 R
方法1：用户自己初始JPEG底层。
9 r' n; }' F# ]% k
8 i4 E9 X+ s$ z- q方法2：定义JPEG_HandleTypeDef JpegHandle为全局变量。
" s7 m( M! v9 U8 K
方法3：下面的方法
% K' w+ `9 K& H, _6 G
" M' ?" g+ H$ l1 B& {5 d

1. if(HAL_JPEG_DeInit(&JpegHandle) != HAL_OK)
   $ \8 A/ a2 U' U+ z& U; v
2. {
   
3.     Error_Handler();
   
4. }  
   
5. if(HAL_JPEG_Init(&Dma2dHandle) != HAL_OK)
   
6. {
   & h( T" |. ^* F/ w1 s4 ]
7.     Error_Handler();
   8 Q6 L8 T! j7 m! A
8. }

复制代码

! o  }3 E8 h! k% h* D* M( d使用举例：
% i! n( p# G6 q7 y

1. JPEG_HandleTypeDef    JPEG_Handle;
   
2. JPEG_Handle.Instance = JPEG;
   % L4 j5 G0 }( @
3. HAL_JPEG_Init(&JPEG_Handle);

复制代码

57.4.2 函数HAL_JPEG_GetInfo
函数原型：

1. HAL_StatusTypeDef HAL_JPEG_GetInfo(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo)
   : E! ^# A9 c1 p' I7 F) @9 M
2. {
   
3.   uint32_t yblockNb, cBblockNb, cRblockNb;
   $ @- B! \+ a; R  J5 }$ X4 B3 ^
4. 
   
5.   /* 检测句柄是否有效 */
   0 L+ M2 b$ W! G- {" U, x
6.   if((hjpeg == NULL) || (pInfo == NULL))
   
7.   {
   " i+ ]3 B9 i* t4 W& F: k
8.     return HAL_ERROR;
   & C- D$ y) M+ \. L5 ]) f
9.   }
   6 ~9 y1 v. ^! q" @  {2 A. e' M
10. 
    7 a: M8 s) ?  e( ]4 p; \6 H
11.   /* 读取配置参数 */
    
12.   if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF_1)
    5 n1 T+ {: n/ P" }" L
13.   {
    + H6 G$ L* H  z* w7 a: h% ]
14.     pInfo->ColorSpace = JPEG_YCBCR_COLORSPACE;   
    1 X4 |$ N$ `7 q( ?$ ^2 Y
15.   }   
    1 ]* Q6 d7 S/ w! b. |4 f
16.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == 0)
    9 L. |* q3 q5 ?7 Q: x
17.   {
    6 u- t9 X2 E- F/ ~6 d) o  j  S. [9 _! I
18.     pInfo->ColorSpace = JPEG_GRAYSCALE_COLORSPACE;
    ; E3 A: `0 d0 i7 H8 ?& V! P
19.   }
    
20.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF)
    ! v5 r! q  h4 o$ `2 r: j
21.   {
    
22.     pInfo->ColorSpace = JPEG_CMYK_COLORSPACE;   
    ) Q! q* N# O8 V% w6 S
23.   }
    
24. 
    - F% J% l' {  a. V
25.   pInfo->ImageHeight = (hjpeg->Instance->CONFR1 & 0xFFFF0000U) >> 16;
    ( M# o8 \2 X3 G- R
26.   pInfo->ImageWidth  = (hjpeg->Instance->CONFR3 & 0xFFFF0000U) >> 16;
    & D6 J6 L) o9 r6 G
27. 
    + b+ ~, n/ a) O) D% T  \3 J
28.   if((pInfo->ColorSpace == JPEG_YCBCR_COLORSPACE) || (pInfo->ColorSpace == JPEG_CMYK_COLORSPACE))
    
29.   {
    
30.     yblockNb  = (hjpeg->Instance->CONFR4 & JPEG_CONFR4_NB) >> 4;
    
31.     cBblockNb = (hjpeg->Instance->CONFR5 & JPEG_CONFR5_NB) >> 4;
    
32.     cRblockNb = (hjpeg->Instance->CONFR6 & JPEG_CONFR6_NB) >> 4;
    # C$ u# X2 s' f8 N5 ^3 R1 D
33. 
    ; o" t  P% z1 p* A/ u8 q+ h
34.     if((yblockNb == 1) && (cBblockNb == 0) && (cRblockNb == 0))
    / n, p. ~5 H4 p7 }
35.     {
    , z, ]# u4 E& S' r4 i5 A! K
36.       pInfo->ChromaSubsampling = JPEG_422_SUBSAMPLING; /*16x8 block*/
    : c5 d7 a5 ?: u( v4 U6 z! g' o6 Q
37.     }
    
38.     else if((yblockNb == 0) && (cBblockNb == 0) && (cRblockNb == 0))
    $ ?; G1 \  [# P, }) V; ]
39.     {
    / W) n2 X$ S5 ?" K2 _3 x
40.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    , I4 u( w' E1 A# o8 D+ L1 g
41.     }
    * m# @# G% a( B" C
42.     else if((yblockNb == 3) && (cBblockNb == 0) && (cRblockNb == 0))
    
43.     {
    * M: v' }8 p: m, U
44.       pInfo->ChromaSubsampling = JPEG_420_SUBSAMPLING;
    
45.     }
    
46.     else /* 默认是 4:4:4*/
    3 o6 K. E' `0 {1 }0 G6 I" O
47.     {
    
48.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    # P& J. @  p: j9 e3 G6 l
49.     }
    ) J1 v) m' w6 L+ F* J; w0 H
50.   }
    
51.   else
    
52.   {
    + x  P2 N5 Z& ]4 S" ^6 f4 ^
53.     pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    
54.   }
    7 f7 p- Y: M3 I! u5 r) Z# |7 k2 @
55. 
    
56.   pInfo->ImageQuality = JPEG_GetQuality(hjpeg);
    5 a+ Z" I. A* P& W
57. 
    
58.   /* 返回HAL_OK */
    
59.   return HAL_OK;
    6 {/ r" [% I0 X3 i0 k+ i
60. }
    

复制代码

函数描述：
; v/ c( A. K: M( d9 @/ N. E) D$ s3 h
1 P8 _! v7 q5 w# C$ [此函数主要用于解码JPEG时获取相关图像信息，比如图像质量，图像长宽等。
$ C/ f# e2 l; B% _
函数参数：
4 E$ T7 _5 v7 X( A6 c- `
  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是JPEG_ConfTypeDef类型结构体指针变量，用于获取JPEG的配置信息，结构体变量成员的详细介绍看本章3.2小
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

3 [) y$ @$ w* J1 @9 J
使用举例：

1. JPEG_HandleTypeDef    JPEG_Handle;
   
2. JPEG_ConfTypeDef      JPEG_Info;
   6 O5 V" M# d+ q. p. _1 {# X
3. 
   5 ~0 o1 s5 B# f% L" }! j0 S; Y2 f/ `
4. HAL_JPEG_GetInfo(&JPEG_Handle, &JPEG_Info);  

复制代码

, j% g& J; W. x6 m+ j2 b: M57.4.3 函数HAL_JPEG_Decode_DMA
函数原型：

8 J+ N, f" d$ O0 m

1. HAL_StatusTypeDef  HAL_JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg ,uint8_t *pDataIn ,uint32_t InDataLength ,uint8_t *pDataOutMCU ,uint32_t OutDataLength)
   
2. {
   % C4 q8 G5 Y/ Z4 O8 g3 W
3.   /* 检测参数 */
   ) o1 g& Z1 N0 y8 f% t
4.   assert_param((InDataLength >= 4));
   
5.   assert_param((OutDataLength >= 4));
   
6. 
   
7.   /* 检测参数 */
   
8.   if((hjpeg == NULL) || (pDataIn == NULL) || (pDataOutMCU == NULL))
   * a  z" W/ {& L# J( s0 m$ b% v. z
9.   {
   
10.     return HAL_ERROR;
    2 X- I9 q9 v/ k
11.   }
    
12. 
    
13.   /* 上锁 */
    8 x8 [% @/ [% h
14.   __HAL_LOCK(hjpeg);
    ! T3 o3 O$ k7 A1 W1 G2 b5 V/ `
15. 
    9 S, {5 w# R# b, @) A+ j. Z
16.   if(hjpeg->State == HAL_JPEG_STATE_READY)
    
17.   {
    
18.     /* 设置JPEG忙 */
    
19.     hjpeg->State = HAL_JPEG_STATE_BUSY_DECODING;
    
20. 
    
21.     /* 设置JPEG上下文，工作在DMA界面状态 */
    
22.     hjpeg->Context &= ~(JPEG_CONTEXT_OPERATION_MASK | JPEG_CONTEXT_METHOD_MASK);
    1 I8 [/ E" U2 v  S
23.     hjpeg->Context |= (JPEG_CONTEXT_DECODE | JPEG_CONTEXT_DMA);         
    : m7 Q3 e( F) N' @, Z" g
24. 
    2 Z; u1 u" B1 b6 a4 r% p* D
25.     /* 设置输入输出缓冲地址和大小 */
    ! Q4 V! c/ O4 M* T1 k: u6 C9 `) T
26.     hjpeg->pJpegInBuffPtr = pDataIn;
      v& P: J, q, ]
27.     hjpeg->pJpegOutBuffPtr = pDataOutMCU;
    
28.     hjpeg->InDataLength = InDataLength;
    
29.     hjpeg->OutDataLength = OutDataLength;
    
30. 
    
31.     /* 复位输入输出缓冲计数 */
    0 W* }7 S2 s" m4 `5 w6 n5 U# u, M
32.     hjpeg->JpegInCount = 0;   
    7 ?; s' k' K# J- P1 H8 M. N8 h
33.     hjpeg->JpegOutCount = 0;   
      A: p+ V) m# E7 B$ b/ o3 K( R
34. 
    . ~' v" x" T8 p
35.     /* 初始化解码处理 */
    & I3 b& z0 z5 o: ^# {# Z% o& c' |, J
36.     JPEG_Init_Process(hjpeg);
      W4 z; C: R: R7 N4 S0 w
37. 
    * C3 V" I" x4 x
38.     /* 启动JPEG解码处理，使用DMA方式 */
    
39.     JPEG_DMA_StartProcess(hjpeg);
    
40. 
    
41.   }
    ) D' t0 a, [* F0 z
42.   else
      t& [# f+ C$ N5 j4 v$ }$ k
43.   {
    
44.     /* 解锁 */
    8 S! g# F8 S* l1 ~1 H) V$ r
45.     __HAL_UNLOCK(hjpeg);
    
46. 
    
47.     return HAL_BUSY;
    
48.   }
    
49. 
    
50.   /* 返回HAL_OK */
    " C; N# ~3 Z% n3 o! c9 O6 t) b( ~
51.   return HAL_OK;
    
52. }
    

复制代码

# U' F! \' K4 S- \5 I函数描述：
2 o% `% B$ s% P7 z; q* z8 m
此函数用于启动JPEG的DMA方式解码。

函数参数：

  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
3 E! K& f+ T" h3 p  第2个参数是输入数据缓冲地址。
# y" z# G# ]0 y8 O- Z  第3个参数输入数据大小，单位字节。
  第4个参数是输出缓冲地址。
  第5个参数是输出缓冲大小，单位字节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。

使用举例：

; g! X& }8 ]9 R

1. /*
   
2. *********************************************************************************************************
   : l1 D+ V- \2 L
3. *    函 数 名: JPEG_Decode_DMA
   
4. *    功能说明: JPEG解码
     ?2 }: C) {( N2 z- k" Z
5. *    形    参: hjpeg               JPEG_HandleTypeDef句柄指针
   
6. *             FrameSourceAddress  数据地址
   
7. *             FrameSize           数据大小
     Z$ U9 u4 a5 q
8. *             DestAddress         目的数据地址
   ! r& G( o+ o6 r% E
9. *    返 回 值: HAL_ERROR表示配置失败，HAL_OK表示配置成功
     ]0 K0 ~1 f6 J8 d" g
10. *             HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出
    6 B3 h# Z! \0 R
11. *********************************************************************************************************
    
12. */
    
13. uint32_t JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg, uint32_t FrameSourceAddress ,uint32_t FrameSize, uint32_t DestAddress)
    
14. {
    
15.     JPEGSourceAddress =  FrameSourceAddress ;
      a* q2 U, e: T7 ^
16.     FrameBufferAddress = DestAddress;
    ( }' c$ ~: ^& }) A3 o
17.     Input_frameIndex = 0;
    
18.     Input_frameSize = FrameSize;
    / m% s( u$ Y1 m, o2 y5 K
19. 
    
20.     /* 设置标志，0表示开始解码，1表示解码完成 */
    ! ]5 Z7 r% N+ L- J1 W' e
21.     Jpeg_HWDecodingEnd = 0;
    - t3 p! |9 I; s# ?8 I& V
22. 
    3 x: J, h; I! w# a
23.     /* 启动JPEG解码 */
    
24.     HAL_JPEG_Decode_DMA(hjpeg ,(uint8_t *)JPEGSourceAddress ,CHUNK_SIZE_IN ,
    
25. (uint8_t *)FrameBufferAddress ,CHUNK_SIZE_OUT);
    
26. 
    - V& a) P& |/ ~" ~
27.     return HAL_OK;
    
28. }

复制代码

57.4.4 函数HAL_JPEG_ConfigInputBuffer
函数原型：
, Y. z5 u; B) v. C

1. void HAL_JPEG_ConfigInputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewInputBuffer, uint32_t InDataLength)
   
2. {
   
3.   hjpeg->pJpegInBuffPtr =  pNewInputBuffer;
   % J' x% |; q8 B. u
4.   hjpeg->InDataLength = InDataLength;
   
5. }

复制代码

3 \+ T% }) ^; v1 Z6 r函数描述：
( u% c) u4 W  l; B5 _  V3 \9 Q
此函数用于配置编解码输入缓冲地址和数据大小。
) g7 P2 B5 A. h
函数参数：

) x& T$ Y  \* c, Y  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
  第2个参数是输入缓冲地址。
  第3个参数是输入缓冲大小，单位字节。
  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
% x6 S' [" L6 ]使用举例：
& K  ]" Q- H7 x

1. /*
   
2. *********************************************************************************************************
   % ], ^5 w+ j, p: {4 a- N  e( ]
3. *    函 数 名: HAL_JPEG_GetDataCallback
   
4. *    功能说明: JPEG回调函数，用于从输入地址获取新数据继续解码
   
5. *    形    参: hjpeg          JPEG_HandleTypeDef 句柄指针
   : o# h  i7 x0 ^8 p( J' p
6. *             NbDecodedData  上一轮已经解码的数据大小，单位字节  
   $ I9 r0 {7 a% [* T: a9 \
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void HAL_JPEG_GetDataCallback(JPEG_HandleTypeDef *hjpeg, uint32_t NbDecodedData)
    
11. {
    3 A" r% Y/ m7 e% B$ d1 j/ P
12.     uint32_t inDataLength;
    8 T' {/ z" K& s
13. 
    
14.     /* 更新已经解码的数据大小 */
    ' I) }4 |( ]6 S
15.     Input_frameIndex += NbDecodedData;
    + L3 X3 j! Q) l! _" B& I
16. 
    
17.     /* 如果当前已经解码的数据小于总文件大小，继续解码 */
    
18.     if( Input_frameIndex < Input_frameSize)
    * p5 Y/ o% U9 a( s
19.     {
    4 h0 h: L8 q: h" s
20.         /* 更新解码数据位置 */
    
21.         JPEGSourceAddress = JPEGSourceAddress + NbDecodedData;
    6 ?, e, y! Z7 W; ~/ x4 M
22. 
    8 B2 H8 }; B& l' N9 ?
23.         /* 更新下一轮要解码的数据大小 */
    " t$ x3 j' _/ H' m& U9 q6 j
24.         if((Input_frameSize - Input_frameIndex) >= CHUNK_SIZE_IN)
    & ^/ {* B9 R3 j3 p3 s  c  \7 d
25.         {
    
26.             inDataLength = CHUNK_SIZE_IN;
    8 |+ b  V6 |( a% T+ S" Y
27.         }
    
28.         else
    8 d" ?& v' q; Y
29.         {
    " x8 h4 v( J0 t, w# Y0 V; ^
30.             inDataLength = Input_frameSize - Input_frameIndex;
    
31.         }   
    
32.     }
    
33.     else
    
34.     {
    
35.         inDataLength = 0;
    
36.     }
    
37. 
    
38.     /* 更新输入缓冲 */
    & d, d( a; L0 E7 k* p
39.     HAL_JPEG_ConfigInputBuffer(hjpeg,(uint8_t *)JPEGSourceAddress, inDataLength);   
    
40. }

复制代码

  s5 w* ?2 j2 r+ I2 I0 W
" g# w/ S1 T; o# ]% U57.4.5 函数HAL_JPEG_ConfigOutputBuffer
7 t3 K+ w/ E2 R4 @& c: W8 l函数原型：
4 Z3 v: d" U9 }' f$ z. w2 X
  n, a8 y9 h) N

1. void HAL_JPEG_ConfigOutputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewOutputBuffer, uint32_t OutDataLength)
   
2. {
   7 x( ~% ]. G8 ~' ~: E9 k8 W
3.   hjpeg->pJpegOutBuffPtr = pNewOutputBuffer;
   
4.   hjpeg->OutDataLength = OutDataLength;  
   / E# t! i4 V% ^; ^1 W' V
5. }

复制代码

0 I+ N* S: s( g" E4 N. C. h. ]
/ V1 L8 O$ |3 V9 l: Y函数描述：
7 K# ~& B7 k/ s
/ p2 j' I* |) G; a此函数用于配置编解码输出缓冲地址和数据大小。
8 p7 p  t$ |1 ?
函数参数：
& D% F$ ], g/ t  o6 Y( ~- j
. j' ~& O5 [3 l0 C. u  第1个参数是JPEG_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数，结构体变量成员的详细介绍看本章3.3小节。
5 \  a* W/ {& H! N; {# Z  ?9 y8 W  第2个参数是输出缓冲地址。
  第3个参数是输出缓冲大小，单位字节。
* }, ?# |/ Q3 n% X- @6 f6 W: j+ `7 |  返回值，返回HAL_ERROR表示配置失败，HAL_OK表示配置成功，HAL_BUSY表示忙（操作中），HAL_TIMEOUT表示时间溢出。
! }& U/ _; `" c9 O7 A使用举例：
& e, `' Y8 U( g; w6 s

1. /*
   
2. *********************************************************************************************************
   4 ^% ^: @) f) o( b% p" r! q
3. *    函 数 名: HAL_JPEG_DataReadyCallback
   
4. *    功能说明: JPEG回调函数，用于输出缓冲地址更新
   
5. *    形    参: hjpeg         JPEG_HandleTypeDef 句柄指针
   ! z: Q% r- S" i) G" D
6. *             pDataOut      输出数据缓冲
   
7. *             OutDataLength 输出数据大小，单位字节
   6 O) |5 W2 l) l
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   
10. */
    ; K9 N6 W. h6 I. g1 s2 L/ q+ p
11. void HAL_JPEG_DataReadyCallback (JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, uint32_t OutDataLength)
    6 c7 X1 q: D$ c9 L
12. {
    
13.     /* 更新JPEG输出地址 */  
    9 t3 G/ }8 t& O& t1 |4 H: t1 T9 n
14.     FrameBufferAddress += OutDataLength;
    
15. 
    % p. e5 D) x& u
16.     HAL_JPEG_ConfigOutputBuffer(hjpeg, (uint8_t *)FrameBufferAddress, CHUNK_SIZE_OUT);
    " [: [% y% J1 N
17. }

复制代码

# _' n* c" N( \; C0 M1 S2 }57.5 总结
本章节就为大家讲解这么多，JPEG功能用到的地方还是比较多的，建议熟练使用。
- {9 m& g" S- z; D. c
; d9 ?% B2 A3 M0 w6 d