你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

【经验分享】STM32H7硬件JPEG编解码基础知识和HAL库API

[复制链接]
STMCU小助手 发布时间:2021-12-21 21:46
57.1 初学者重要提示
& [+ @) J/ L0 _  z4 J0 A' o  由于硬件JPEG解码后输出的图像格式是YCbCr,所以本章对YCbCr进行了重点介绍。
8 h! v% x6 y/ V! B7 h# h9 A0 F  测试STM32H7硬件JPEG解码800*480图片性能,全部通过SDRAM缓存数据,解码10ms,显示9ms。
+ ^7 F: a% b' V" y  JPEG涉及到的知识点还是比较多的,如果想深入了解JPEG的话,可以看本章2.6小节给的参考资料。- D( R3 X9 k  `" z( p
  本章JPEG相关概念的介绍参考了wiki百科和百度百科。
9 {& ^5 ~* ~. ^  H# P% h+ F) t57.2 硬件JPEG基础知识
! o( T1 q% S( x  D
对于STM32H7的硬件JPEG了解到以下几点即可:
* S# x. [& ^6 e& f: B9 @
& k) j+ k7 L8 X7 n$ l; \. n. A" e  支持JPEG解码和编码。4 V7 S+ ?6 N& D0 v3 S+ w& [6 \
  对每个像素数据进行编解码只需一个时钟周期。
$ s) H3 `2 O0 Y  支持RGB、 YCbCr、YCMK和BW(灰度)图像色彩模型。) c  J8 {1 x  ~! \. i( n: o
  编解码时每图像分量8位深度。9 @1 H4 v5 r5 ?6 C. q3 O

; U, v( j5 n" l: w, p1 U" F1 F. a$ P# V57.2.1 JPEG硬件框图
  y$ k8 H2 w9 R* q9 S认识一个外设,最好的方式就是看它的框图,方便我们快速地了解JPEG的基本功能,然后再看手册了解细节。框图如下所示:$ w. {  _3 W) p! j/ K
8 T4 j; L! `. x
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2NvbW1vbi8xMzc5MTA3LzIwMjAwMi8xMzc5MTA3LTIw.png

& E6 e- j+ ?' p# e% c0 @, f% q& v& N& S5 u4 w$ x) P  ]
通过这个框图,我们可以得到如下信息:
  L3 a: W* p* L, s& M( i0 ~1 u5 N" A6 p% Z8 l/ ~- s
  JPEG硬件外设支持编码和解码
; X7 ~5 e; o, E5 H$ a并且对于输入数据和输出数据都有FIFO支持。0 y4 _  p9 A0 N1 H4 R
, a! p- V& H* S7 l' v. z
  jpeg_hclk
/ S* }+ ^7 s5 S8 N3 `8 P为JPEG内核和寄存器提供时钟。
* v+ x8 }" Z& W$ y
$ q& h* D% k. S8 v- j; J- w: ?  jpeg_it
. a  v) _/ r5 RJPEG全局中断输出。" f9 Q& q$ E" G8 f! V. D9 V# _

$ u) S" d4 J+ Z' K/ N2 g; Z, |  jpeg_ift_trg
% f* }3 g. F, N- Z3 B, lJPEG输入FIFO阈值信号,可触发MDMA。
, ]# ^! p" n9 k" r( f2 Z3 V
8 Q- [7 }) o8 t0 X1 T! @  jpeg_ifnf_trg& L6 p- ]; i$ d' P* w& I
JPEG输入FIFO未满信号,可触发MDMA。% |. l  i5 d) y
8 L/ X  Z. O: G; s. p* {, {% v7 [
  jpeg_oft_trg. V' b& U, ?& e' ~7 t* A
JPEG输出FIFO阀值信号,可触发MDMA。
3 Y/ I  `9 K) K+ S6 S: k
4 p4 r  c: k% E0 y4 R) e& f! y2 I  jpeg_ofne_trg
" i: Y& q5 l; x8 d; G% zJPEG输出FIFO非空信号,可触发MDMA。2 w6 i% l/ _/ o2 Z
" R$ P$ o" j6 L( ^7 a' ^- W
  jpeg_oec_trg7 D9 D- U* G; _. L% s1 o- O) W
JPEG转换结束信号,可触发MDMA。" H2 H7 Y, m+ N: J6 [. g

/ I1 F' @: u+ P' Q! F+ X57.2.2 YCbCr颜色格式
! l& X! j* f2 a3 V, B9 W(注,硬件JPEG解码后输出的图像格式是YCbCr,所以有必要了解下)
# t* m4 s2 E; v5 o! r6 l
; Q& T" t5 f& c" o! Z- i正如几何上用坐标空间来描述坐标集,而色彩空间用数学方式来描述颜色集。常见的3种色彩模型是RGB,CMYK和YUV。
. |/ Z( j7 A7 |  G8 D1 d1 t2 C
: w' K% h# J& A. Y+ ]YCbCr是YUV经过缩放和修改的翻版,只是在表示方法上不同。其中Y是指亮度分量,Cb指蓝色色度分量,而Cr指红色色度分量。人眼对视频的Y分量更敏感,因此通过对色度分量进行子采样来减少色度分量后,人眼察觉不到的图像质量的变化。
* Q- N2 T5 F% P2 L3 F9 r0 s, s7 G
" {1 p0 B) p9 }/ Y3 v在YUV 家族中,YCbCr 是在计算机系统中应用最多的成员,其应用领域广泛,JPEG、MPEG均采用此格式。一般人们所讲的YUV大多是指YCbCr。( H+ c( o/ i* P: M' Z+ q+ Q

2 y+ g, V4 U) M+ S0 G57.2.3 YCbCr采样格式! L- L$ m+ H) [
YCbCr有许多取样格式,如YCbCr 4:4:4,YCbCr 4:2:2,YCbCr 4:1:1 和YCbCr 4:2:0。5 b" V* G; \/ U4 {" D8 R

: y$ V4 N% `* y5 o" {' v# G  4:2:02 a) Y$ ^9 y8 L4 v
表示每4个像素有4个亮度分量,2个色度分量 (YYYYCbCr),仅采样奇数扫描线,是便携式视频设备(MPEG-4)以及电视会议(H.263)最常用格式。
4 n( U" T* @4 S  `% i7 r" E) k& a0 s0 x7 c3 c
  4:2:2
3 G6 A  e3 q  W# h; O+ x; X2 s表示每4个像素有4个亮度分量,4个色度分量(YYYYCbCrCbCr),是DVD、数字电视、HDTV以及其它消费类视频设备的最常用格式。. C6 I. a) s% Y+ I* G1 W  j6 T# ^

8 B8 j) I+ G1 S: s# B  4:4:4
6 D2 h7 w/ w) b& i表示全像素点阵(YYYYCbCrCbCrCbCrCbCr),用于高质量视频应用、演播室以及专业视频产品。
8 [* m% ^5 [2 p; s/ j: F/ V. Q, }" t! N% g
具体的采样方式如下图所示,以8个像素为一个单元进行采样:
7 P- U6 R3 l) ]- V0 ?+ N7 N- H! \% h! W/ `$ j
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2NvbW1vbi8xMzc5MTA3LzIwMjAwMi8xMzc5MTA3LTIw.png
4 R, t: y: M9 c/ H+ P
) y( @# N: T- |6 ?
由上面的截图可以了解到:
, T" T$ D9 [% ^( ~2 V7 |+ \7 T- o5 w! Z
4:4:4表示Y通道,Cb+Cr通道全部采样。( r6 v" Q, M( E$ `6 k2 ]2 j' a6 a
1 [/ o$ I. E& Y
4:2:2表示Y通道全部采样,而Cb+Cr通道两个像素为一组,统一采用第1个颜色值。  D' O- W- c4 e2 t% B

- h6 u+ v! W+ F  r0 P4:2:0表示Y通道全部采样,而Cb+Cr通道四个像素为一组,统一采用第1个颜色值。
5 Z9 B& p- y; |+ [# r' I- l* p) I5 N( a: R3 J4 R
下面是整体效果,方便大家更好的理解:) T  l$ x2 q& ~$ J8 ~3 A. h
, y: ^" ]/ }2 _( x0 {2 K
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2NvbW1vbi8xMzc5MTA3LzIwMjAwMi8xMzc5MTA3LTIw.png
0 H; T4 W$ J: c( `  ^
% G2 ^5 ^# A) v; S% v
$ ?" ?; O! r6 W; k4 g# G" T4 E

: `2 i- B- M  o4 R7 u2 s57.2.4 YCbCr的优势6 ]6 Z" n7 {, f: ~
RGB信号作为存储和传输的效率不高,因为它们具有大量冗余信息。而使用YCbCr可以丢弃一些信息以减少带宽,因为人的肉眼对视频的Y分量更敏感,因此通过对色度分量进行子采样来减少色度分量后,肉眼察觉不到的图像质量的变化。了解这种人为缺点,NTSC和PAL等标准大大降低了色度通道的带宽。
' b$ b( r2 J. d2 V: Z3 [' U/ l8 t$ y/ d
57.2.5 YCbCr和RGB互转

& v. ^3 o  B4 k/ o为了方便大家更好的了解YCbCr和RGB图像的实际效果,特此搜集整理了两个截图(来自WIKI百科)。下面是图像转YCBCR的效果:四个图,从上到下依次是原始图像,Y通道,Cb通道和Cr通道。
8 P6 m/ l* s8 W9 r( h# T8 g7 Q; b  J+ P; t8 w7 d
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2NvbW1vbi8xMzc5MTA3LzIwMjAwMi8xMzc5MTA3LTIw.png
& ~0 ~" Z5 H. J% v0 A' X
$ [$ `: P+ U2 `5 v" k
下面是一幅图像分别以R,G,B通道和Y,CB,CR通道的方式展示:
& R7 X( D1 ?$ m6 R8 f: m+ t" q% q
# y. a6 |0 [) [9 r" r
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2NvbW1vbi8xMzc5MTA3LzIwMjAwMi8xMzc5MTA3LTIw.png

2 G. X3 ]) V2 C  D2 K: v& H* F, u4 l5 a0 o9 \( s
57.2.6 JPEG编解码知识5 d) ^8 j9 [) l+ G
JPEG涉及到的知识点比较多,这里有之前整理的20多个专题知识点,大家有兴趣可以了解下(不了解也没有关系,不影响使用硬件JPEG外设)$ C1 z  {7 ]% \4 b
2 d! Y. s0 q) A
57.3 硬件JPEG的HAL库用法- X8 I! N2 z/ y$ _
JPEG的HAL库用法其实就是几个结构体变量成员的配置和使用,然后配置时钟,并根据需要配置NVIC、中断和MDMA。下面我们逐一展开为大家做个说明。' F4 H1 [) [8 c3 q9 e" r/ T

* M# |% c- {, g8 m( W9 |- T57.3.1 JPEG寄存器结构体JPEG_TypeDef
! j' e- z4 x. @# _' d0 j" jJPEG相关的寄存器是通过HAL库中的结构体JPEG_TypeDef定义的,在stm32h743xx.h中可以找到它们的具体定义:) R& |1 a4 e' z2 W

: \1 B4 i- [6 O$ j
  1. typedef struct$ ]) T' B* f4 `$ l" W
  2. {
    % b& v' A. Q3 \5 M
  3.   __IO uint32_t CONFR0;         
    , t. A  |8 t- M1 n6 _5 u
  4.   __IO uint32_t CONFR1;            q: f- X' l5 w
  5.   __IO uint32_t CONFR2;        : ]6 T" Y1 T9 i2 N6 e0 H
  6.   __IO uint32_t CONFR3;        2 w# f: i" D( e( C5 f1 p  x
  7.   __IO uint32_t CONFR4;         
    8 y0 g4 X- i( T& R/ v  [
  8.   __IO uint32_t CONFR5;       - ~7 U4 z& S  D+ }! }, a6 E
  9.   __IO uint32_t CONFR6;      
    - U# R4 w' c6 v$ T# n  ~# }
  10.   __IO uint32_t CONFR7;        
    4 M# u! _% `& ~3 i! K- W% }; r
  11.   uint32_t  Reserved20[4];      1 }  I( ]0 ]+ T0 U0 G' D
  12.   __IO uint32_t CR;            
    7 g* [/ h( l1 t1 m  Z/ Q
  13.   __IO uint32_t SR;            
    " A% r1 M4 J$ q  {8 i6 H
  14.   __IO uint32_t CFR;            3 i8 G/ @0 U! D0 B: |8 M  F  `
  15.   uint32_t  Reserved3c;        # ~7 n2 K( ]; {
  16.   __IO uint32_t DIR;          ; ]3 E4 B+ J' q% e+ l. H2 @, ]
  17.   __IO uint32_t DOR;            0 x% g+ Q8 K8 [" v" Z
  18.   uint32_t  Reserved48[2];      - t6 D" K4 _$ L
  19.   __IO uint32_t QMEM0[16];     
    3 S/ Z$ e& r0 Y* A; p$ J
  20.   __IO uint32_t QMEM1[16];       $ ?3 }  x6 ]! ?9 d  y1 \
  21.   __IO uint32_t QMEM2[16];      
    % @6 Z, u; c" p: h, ?/ ~* T
  22.   __IO uint32_t QMEM3[16];       / @0 w( A+ j" N" \
  23.   __IO uint32_t HUFFMIN[16];    6 B0 b. X, K& j1 U+ g5 p
  24.   __IO uint32_t HUFFBASE[32];   
    / N* Z% m- W# s+ {6 m9 N
  25.   __IO uint32_t HUFFSYMB[84];   ! l4 h; S( ~2 A
  26.   __IO uint32_t DHTMEM[103];   9 T9 O9 f: X% w  S1 o. P
  27.   uint32_t  Reserved4FC;      , u: h+ P- P) ]( G: O
  28.   __IO uint32_t HUFFENC_AC0[88]; 6 |$ w& `" c- u( \- ^
  29.   __IO uint32_t HUFFENC_AC1[88];
    " E( z3 F- N3 x8 I
  30.   __IO uint32_t HUFFENC_DC0[8];  
    + ], }' U) |/ b" ~/ H8 w; z
  31.   __IO uint32_t HUFFENC_DC1[8];
    0 O8 W7 o0 s. W' d( C
  32. } JPEG_TypeDef;
复制代码

+ ]* V) _9 Q9 s5 Y__IO表示volatile, 这是标准C语言中的一个修饰字,表示这个变量是非易失性的,编译器不要将其优化掉。core_m7.h 文件定义了这个宏:. V* W, L) a% O7 T7 x

( w$ n5 l- F( D' o+ X% x0 L
  1. #define     __O     volatile             /*!< Defines 'write only' permissions */% x: b: w" U- u
  2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */
复制代码

4 V- W7 H, Z3 o. `下面我们再看JPEG的定义,在stm32h743xx.h文件。
8 k2 t( h' u0 e" G% U
) G6 u9 P( d. l5 m' O
  1. #define PERIPH_BASE           ((uint32_t)0x40000000)# E+ m1 B2 f, c* `
  2. #define D1_AHB1PERIPH_BASE    (PERIPH_BASE + 0x12000000)2 c8 C" u8 d, S( U6 e5 o; w
  3. #define JPEG                  ((JPEG_TypeDef *) JPGDEC_BASE); E4 l+ ~# l. q: j8 |
  4. #define JPGDEC_BASE           (D1_AHB1PERIPH_BASE + 0x3000) <----- 展开这个宏,(JPEG_TypeDef *) 0x52003000
复制代码
, k5 x- E* v1 \& B, H/ l
我们访问JPEG的CR寄存器可以采用这种形式:JPEG->CR = 0。( \2 Y5 x+ x! y9 V6 Q8 M
. l' l. L# S) Y$ p, L
57.3.2 JPEG的编解码参数结构体JPEG_ConfTypeDef
* D: V  k4 Y% u- J此结构体用于JPEG的编解码参数,具体定义如下:
$ r, F0 `: V. d9 q- Q$ a. U" L8 \
8 }% b3 _) M/ ~7 K! c
  1. typedef struct
    , n  l, y6 X9 d! ^
  2. {
    4 J$ x; W2 m5 m7 \. A7 F7 O' {0 Y
  3.   uint8_t  ColorSpace;               + }* c0 e7 [1 M' e# g6 o  a
  4.   uint8_t  ChromaSubsampling;        
    3 X6 \$ T: T- c4 Q) d
  5.   uint32_t ImageHeight;              ; D9 A3 }' V7 ]4 u9 n
  6.   uint32_t ImageWidth;            
    + e4 ]9 h0 C; ?; }, J* Z1 Z
  7.   uint8_t  ImageQuality;               7 \% {; c. {- P
  8. }JPEG_ConfTypeDef;
复制代码
5 }" r  I! r: m6 I) j
下面将这几个参数逐一为大家做个说明:3 Q: r# j, V. q7 o& g
  uint8_t  ColorSpace
0 o- U/ K7 c" j+ C% N+ N7 z2 C" [4 h' I1 w
% O& p( G0 h8 w+ \& s
此参数用于设置输出数据流中的量化表,具体支持的参数如下:
' M3 G- v3 j5 V. c; f  \  Q. g# p5 l
  1. #define JPEG_GRAYSCALE_COLORSPACE     ((uint32_t)0x00000000U)    /* 灰度(1 个量化表)*/
    & Y- i" ^" ?  `- \2 O
  2. #define JPEG_YCBCR_COLORSPACE         JPEG_CONFR1_COLORSPACE_0   /* YUV(2 个量化表) */
    ( q! A9 O* J' P
  3. #define JPEG_CMYK_COLORSPACE          JPEG_CONFR1_COLORSPACE     /* CMYK(4 个量化表)*/
复制代码

) q; A" a" p' S8 n  uint8_t  ChromaSubsampling
- e# T- R# y; x& r此参数用于色度子采样,具体支持的参数如下:
. Z* A7 N& S* q1 W4 _4 {0 ]* G
' e) R- y; W6 l" `
  1. #define JPEG_444_SUBSAMPLING     ((uint32_t)0x00000000U)   /* 4:4:4 */0 t% M( [% A# a  A+ o! i
  2. #define JPEG_420_SUBSAMPLING     ((uint32_t)0x00000001U)   /* 4:2:0 */$ o( u2 w' U5 m& N. d( q0 U7 I  @. [
  3. #define JPEG_422_SUBSAMPLING     ((uint32_t)0x00000002U)   /* 4:2:2 */
复制代码
# \) b! i2 M2 f% O5 t3 {) [( @0 ~/ h
  uint32_t  ImageHeight5 M! `& `9 Y8 {9 y1 A; e
此参数用于图像高度。
) y5 t& v) W% R" W
9 t! w! K% |" W2 g4 M, |( N  uint32_t ImageWidth
$ U3 Q3 e4 o0 n. s此参数用于图像宽度。
/ L( @. [0 y4 e( k1 ]
. F- W, m9 q+ e& H: F$ f- y  uint8_t  ImageQuality
5 B$ m2 I4 x+ `  O此参数用于图像质量,参数范围1 – 100,1最差,100最好。
/ B3 L% X$ S, }# e6 _4 k# h( R& C3 h! Q1 D: ~/ {$ X, s
57.3.3 JPEG结构体句柄JPEG_HandleTypeDef3 S& ]; i  i+ s2 O
HAL库在JPEG_TypeDef, JPEG_ConfTypeDef的基础上封装了一个结构体JPEG_HandleTypeDef,定义如下:
2 b/ t6 [; Y5 U; k) `  v9 C- s9 V
* V( C3 P6 y8 \2 Y
  1. typedef struct
    6 X2 x# @6 x: H, Z1 a6 G
  2. {
    , q( M6 _# m! S  W) V/ [( S% G
  3.   JPEG_TypeDef             *Instance;        
    0 E+ t% ~$ D7 d" z% e4 q/ b$ H9 G6 O
  4.   JPEG_ConfTypeDef         Conf;            
    / ?* _) B+ x  ?! I" a8 `
  5.   uint8_t                  *pJpegInBuffPtr;
    6 D; X: m$ {' O  R$ b
  6.   uint8_t                  *pJpegOutBuffPtr; 7 D+ U% y. [' R* c/ D, X, y
  7.   __IO uint32_t            JpegInCount;      
    ; H: U1 [' B6 r
  8.   __IO uint32_t            JpegOutCount;     
    . P- i" \) i  H9 b7 \9 m
  9.   uint32_t                 InDataLength;     
    + ^  A+ T! O! F& `" Z6 P
  10.   uint32_t                 OutDataLength;     
    8 r  _' y# Q  Y1 S) z" M. l" d
  11.   MDMA_HandleTypeDef        *hdmain;         
    3 ~% G% \- m* ]4 P, D; |
  12.   MDMA_HandleTypeDef        *hdmaout;        - H. N, v, |! Q  ^7 K( J& U) e
  13.   uint8_t                  CustomQuanTable;
    9 u8 ~) u( j" T+ l
  14.   uint8_t                  *QuantTable0;   
    + s6 d$ d4 Q7 ^0 N# g! T* N1 D
  15.   uint8_t                  *QuantTable1;   
    9 @, H9 [0 M' x) e7 _4 `: ]/ `
  16.   uint8_t                  *QuantTable2;    ! I3 `; O" C2 F; l* q
  17.   uint8_t                  *QuantTable3;         
    9 `  e! j; U9 f" }
  18.   HAL_LockTypeDef          Lock;            
    7 h- L; T: p' ^7 r8 k9 C2 t' }6 a
  19.   __IO  HAL_JPEG_STATETypeDef State;         , l- c. W! ?9 L; J9 O. D  W- V
  20.   __IO  uint32_t           ErrorCode;      6 u8 D8 z5 n7 p9 l0 K
  21.   __IO uint32_t Context;                    ( Z6 {! T; R* P1 I8 ]
  22. }JPEG_HandleTypeDef;
复制代码
( a& `! f2 y& a- l1 V! J% b
下面将这几个参数逐一做个说明。
% y1 y7 B& _. P  c3 i. K
5 J3 E- c- V: Y( N; P6 _  JPEG_TypeDef   *Instance' x- ^% t6 u# k, e* M
这个参数是寄存器的例化,方便操作寄存器,详见本章3.1小节。. M- r1 \" x- Y8 w# l4 o9 C
/ T/ m  \9 c! k+ A
  JPEG_ConfTypeDef   Conf3 t* M% A) h2 `
这个参数是用户接触较多的,用于JPEG的编解码参数,详见本章3.2小节。
& J6 n5 D; r/ e* ^2 W1 e  v+ h9 m  Z
  uint8_t       *pJpegInBuffPtr! \% y4 Y/ C/ U1 ]
JPEG编解码输入缓冲地址
) h+ K: x( s- n( D0 [
  \: _: O9 g$ ~2 x  uint8_t       *pJpegOutBuffPtr
/ I4 G" A6 o2 ]$ \/ A5 x5 NJPEG编解码输出缓冲地址: P* p# h) t- ?$ |# s! L

% X" c5 \& n# v! Q  __IO uint32_t   JpegInCount
# o" E' ^- D" b. z" _) J+ P/ ]  OJPEG内部输入计数。
( ?3 n% }3 n/ R' f0 c; q7 }, j1 \" n' N3 r. G: E2 b  d: o; g
  __IO uint32_t   JpegOutCount7 y& {( m: c1 ~( Z% b# k. c
JPEG内部输出计数。
3 h3 z! }1 U+ {2 r4 I+ ^5 A6 n- z# u% y, z! T9 ?3 Y+ W
  uint32_t        InDataLength; l# n. R0 U8 k8 n$ C7 }+ L
JPEG输入缓冲区长度,单位字节
1 Q: x" d" B- @6 p. H* q4 \$ \" v) S% x
  uint32_t          OutDataLength' a8 ^4 u8 [& Z  n" W
JPEG输出缓冲区长度,单位字节。" J1 L, \9 J( a' p5 d2 V

, {# Z2 [9 N2 f# v5 }4 z+ X6 e( l  MDMA_HandleTypeDef        *hdmain# Q; s! l# A" h2 ^
  MDMA_HandleTypeDef        *hdmaout: |1 H, d% I( i7 _( }8 A8 J- Z
MDMA句柄结构体指针变量,用于关联JPEG句柄,方便调用。
  V7 e; F( }# F6 P3 B2 j. ?  C4 r1 h+ y6 V) ?: B# R
  uint8_t       CustomQuanTable6 H0 y% o0 e$ W6 M& h
如果此参数设置为1,将使用用户设置的量化表。
; q! K- Y* t# q$ h3 B1 r1 i; N" W" r# ]& h- ?
  uint8_t      *QuantTable0;   8 V+ t! R$ F$ H
  uint8_t      *QuantTable1;     
' ~8 p$ c+ S1 [7 u5 E. j9 R  uint8_t      *QuantTable2;    9 g/ S: d4 `' j$ J, L/ P
  uint8_t      *QuantTable3;2 l# m+ G; P. q' W
指定量化表地址。   
) R6 t! u" S; ^- k& \$ P: W
; N4 M: g+ _0 u) j6 B4 b: C  HAL_LockTypeDef          Lock           3 a7 H3 O( ~( G, C$ E
  __IO  HAL_JPEG_STATETypeDef State           # l. N% K* q- B: b- _! e3 N
  __IO  uint32_t           ErrorCode      , g- w7 U5 l* \; p  e
这三个变量主要供函数内部使用。Lock用于设置锁状态,State用于设置JPEG状态,而ErrorCode用于配置代码错误。
. V/ u# h& t3 P  y( k+ {3 {
. s; P( x1 P3 R- ]5 C4 I  __IO uint32_t Context
( I, J7 t: w% A0 yJPEG上下文。# W1 \$ M' l5 [
. u. D, N! j+ [% i( X
57.3.4 JPEG初始化流程总结
8 [+ B' I6 I+ Q/ f0 M1 e' S( b7 J使用方法由HAL库提供:$ b- s$ S- H1 P  t, J
- B' m) Z, ~8 |% b( G
  第1步:调用函数HAL_JPEG_Init进行初始化,但这个函数不需要初始化参数。- T, _. W. g: d! K2 G- ]1 r
( F' T. X0 V8 d; P& J. y  p
如果是JPEG编码,可以通过函数HAL_JPEG_ConfigEncoding设置JPEG图像的质量参数,质量越高,生成的JPEG文件越大、! d& Z  O* J7 }: m% }

5 R% D, i6 s3 c9 W; d: ?# p' a  第2步:调用编解码函数
' o, ?0 u2 K. A) ^$ u) r
7 b8 r. W: @; E0 {' G7 s  查询式编解码函数
$ D+ j8 `0 _; S+ A& T# K2 NHAL_JPEG_Encode
. v+ G1 k  {  s: D8 Z5 Q
# D. x. @8 r; \7 JHAL_JPEG_Decode, U6 q# S( v( z# S

% c# N& _; l. L( o  |9 b
2 [0 y( A, v: j- k0 w( j+ U, }0 I9 ^- B5 b5 `. C4 ^- c
  中断方式+ g2 N: b7 H0 {8 Q2 g- y
HAL_JPEG_Encode_IT' G1 T. X; |" |" y9 n; G+ N3 J

5 t9 v% `6 d# B) s5 ?9 QHAL_JPEG_Decode_IT
- |1 [" i" p: y! P. `8 d3 n) c2 p, t* R2 ?

# `7 f+ z7 m5 A( j) A
+ D& E5 v" k1 k6 [  h  DMA方式
; n; k% `8 M. S6 p# L7 xHAL_JPEG_Encode_DMA
& X- R# O# ]" G4 W+ v5 N  t; y- j
  J( ]' \0 d1 n, L1 CHAL_JPEG_Decode_DMA
3 a0 I  F  J/ X6 Q$ g) {! m5 r# n% `4 [7 T' N
  第4步:如果用户之前的数据已经处理完毕,需要插入新数据,会调用函数HAL_JPEG_GetDataCallback
$ E: C7 G/ E2 A2 T. h& y
( T" N9 D! Y' G, P+ c. Z1 a5 s(1)如果新的数据已经准备好,需要调用函数HAL_JPEG_ConfigInputBuffer。如果新的数据没有准备好,需要等待插入新数据时,可以调用函数HAL_JPEG_Pause(参数XferSelection被设置为JPEG_PAUSE_RESUME_INPUT),待数据准备好后,可以调用HAL_JPEG_ConfigInputBuffer设置新的输入缓冲和大小,然后调用函数HAL_JPEG_Resume恢复JPEG编解码。2 C5 o5 }- b* @3 c- _4 H7 z
0 D7 h+ O- k+ s/ ]0 X8 D
如果编解码的数据已经处理完毕,可以调用函数HAL_JPEG_ConfigInputBuffer设置InDataLength参数为0(此函数是在回调函数HAL_JPEG_GetDataCallback里面被调用的)。
& F, x  W' q* U0 L0 t
  |6 e' u' J! l/ n
2 {8 H- t3 I7 n: V' d(2)函数HAL_JPEG_ConfigInputBuffer/HAL_JPEG_Pause/HAL_JPEG_Resume的工作机制允许应用程序以块为单位提供输入数据。如果新的数据块未准备好,可以调用函数HAL_JPEG_Pause暂停输入,待数据准备好后,可以调用HAL_JPEG_ConfigInputBuffer设置新的输入缓冲和大小,然后调用函数HAL_JPEG_Resume恢复JPEG编解码。6 S9 d6 G  [+ A1 t# {
; v' E" x, J5 Z! \# t3 i% N4 h

% R" n4 m0 U8 U# c" K" f+ g/ K* D(3)新的数据块准备好后,可以在回调函数HAL_JPEG_GetDataCallback外面调用HAL_JPEG_ConfigInputBuffer 和 HAL_JPEG_Resume,但是为了保持数据一致性问题,务必在回调函数HAL_JPEG_GetDataCallback里面调用HAL_JPEG_Resume。8 x! c/ `0 S2 I! H+ Y4 m
. S2 j/ b% V. y

/ {5 z2 ~/ O5 i2 y  ~; w  第5步:输出缓冲区填充了给定大小的数据后,会调用回调函数HAL_JPEG_DataReadyCallback
# J3 J# R5 E/ a5 n" L
! C: F$ z* V% {" \7 U(1)如果有数据空间存储新数据块,需要调用函数HAL_JPEG_ConfigOutputBuffer配置新存储位置。如果没有数据空间存储新数据块,需要等待有数据空间可用时,可以调用函数HAL_JPEG_Pause(参数XferSelection被设置为JPEG_PAUSE_RESUME_INPUT),待有数据空间可用时,可以调用HAL_JPEG_ConfigOutputBuffe设置新的输出缓冲,然后调用函数HAL_JPEG_Resume恢复JPEG编解码。' U8 ?$ s) L4 R) a% ]

" A6 D% D# K/ g- c(2)函数HAL_JPEG_ConfigOutputBuffe/HAL_JPEG_Pause/HAL_JPEG_Resume的工作机制允许应用程序以块为单位接收数据。当接收到数据块时,应用程序可以暂停JPEG输出来处理这些数据,比如解码时YCbCr转RGB或者编码时数据存储。
/ [5 E% s# K+ f" m$ K" g% d+ @
- C5 z% ~  i0 u2 h(3)新的数据空间准备好后,可以在回调函数HAL_JPEG_DataReadyCallback外面调用HAL_JPEG_ConfigOutputBuffer和 HAL_JPEG_Resume,但是为了保持数据一致性问题,务必在回调函数HAL_JPEG_DataReadyCallback里面调用HAL_JPEG_Resume。5 o. i$ A+ a4 j

8 Y: e; g+ g( `7 u" d1 u" {: V
  第6步:其它相关函数% L- v8 k. B$ j4 c

: L9 d5 G" z4 I8 Q: [2 ^  JPEG解码时,如果解码成功,会调用回调函数HAL_JPEG_InfoReadyCallback。& M, e4 \* j, V
  JPEG编码操作结束后会调用回调函数HAL_JPEG_EncodeCpltCallback。
& M2 k/ e4 ?( h' S0 }2 a/ v6 n& H+ `  JPEG解码操作结束后,会调用回调函数HAL_JPEG_DecodeCpltCallback。
; Y, l9 k/ ~' b. ?  操作过程中出现错误,会调用回调函数HAL_JPEG_ErrorCallback,用户可以调用函数HAL_JPEG_GetError获取错误类型。
& M: x; c$ j0 Q8 t  HAL JPEG默认使用的是ISO/IEC 10918-1规格量化表,如果要修改,可以调用函数HAL_JPEG_SetUserQuantTables实现。' l* }/ G/ F+ J& r" O6 {* F% z$ C
  通过函数HAL_JPEG_GetState可以获取JPEG状态。
' Q, B, H; @" b/ O* b) n5 }8 a% l% |5 Y
7 {5 e% H9 b% c5 _6 _( B3 ]
57.4 源文件stm32h7xx_hal_jpeg.c# l% ?+ Z- @8 a1 S, r3 n1 e
这里把我们把如下几个常用到的函数做个说明:1 U- ]; V6 @8 G( ~5 l
. v1 G0 e  J4 L. G4 ]* R/ u
  HAL_JPEG_Init
9 A; ]. w+ X, N) D! n  HAL_JPEG_GetInfo
8 i% R. R7 k3 `! V- c8 e  HAL_JPEG_Decode_DMA
. T) L9 c2 f* W8 K6 l' O" x  HAL_JPEG_ConfigInputBuffer/ u! D7 ^  v- x0 N2 B* Q
  HAL_JPEG_ConfigOutputBuffer
# K' g0 z' v' M) d  w! F  _( Z% C$ w0 U  G, ]4 Y
57.4.1 函数HAL_JPEG_Init* G1 k1 r. v# @
函数原型:
1 J0 V% x  a: g4 k+ l- W9 `
2 d% B% l1 G- W: l% K8 N
  1. HAL_StatusTypeDef HAL_JPEG_Init(JPEG_HandleTypeDef *hjpeg)! p4 j/ [* H! L: z
  2. {0 |* _6 m& r# R' m) F
  3.   uint32_t acLum_huffmanTableAddr = (uint32_t)(&JPEG_ACLUM_HuffTable);
    3 l# _% z  |* U% T
  4.   uint32_t dcLum_huffmanTableAddr = (uint32_t)(&JPEG_DCLUM_HuffTable);' @9 m9 [6 v# j$ A' @% W
  5.   uint32_t acChrom_huffmanTableAddr = (uint32_t)(&JPEG_ACCHROM_HuffTable);; D' e. j+ @  Q/ J6 x
  6.   uint32_t dcChrom_huffmanTableAddr = (uint32_t)(&JPEG_DCCHROM_HuffTable);
    1 p- \7 d# N! K2 f
  7.   j) E" Y# G6 h6 q7 u. \7 B. y6 n
  8.   /* 检测句柄是否有效 */. W& C/ V+ K5 d0 v! o/ [0 }/ p
  9.   if(hjpeg == NULL)) c! |# |- ~) V2 t/ a! F
  10.   {0 w1 T+ Y# }5 w) j- D" ~
  11.     return HAL_ERROR;
    & g$ |5 a: G8 ^4 o! ]# v$ p
  12.   }" q1 y3 q1 ?: ^) q/ U% W

  13. 7 [9 n- y6 F# D9 W9 _7 m
  14.   if(hjpeg->State == HAL_JPEG_STATE_RESET)6 j/ u1 L1 Q4 Q/ w
  15.   {
    % ~* A+ X9 l: s0 ]6 m
  16.     hjpeg->Lock = HAL_UNLOCKED;
    2 [' ^& ]2 V  Y) D; u* V

  17. 3 V$ H7 x7 C0 Q1 K7 y9 ?
  18.      /* 初始化GPIO,NVIC等 */1 e2 X7 N0 v6 k, {7 V
  19.     HAL_JPEG_MspInit(hjpeg);$ o1 c9 Y8 L. r* j
  20.   }
    ) P6 R% y  \/ q4 s" {' `# }. D9 C
  21. ) w& g- g6 z8 u5 u' T: b
  22.   /* 设置JPEG状态 */
    . A+ X' X5 e) @
  23.   hjpeg->State = HAL_JPEG_STATE_BUSY;
    ' P* |9 v5 v6 B" h4 x' u/ o2 h
  24. 1 W. K* M3 G: A0 Z$ A0 y' g
  25.   /* 使能JPEG  */
    6 Y* T9 N5 W/ j0 f: O
  26.   __HAL_JPEG_ENABLE(hjpeg);* Y+ J2 ^! I8 f# ^5 x
  27. ( t- H0 R! q7 `/ e6 e' Z; x
  28.   /* 关闭JPEG编解码处理 */* h5 f" T' e. J( f" Y
  29.   hjpeg->Instance->CONFR0 &=  ~JPEG_CONFR0_START;8 |/ D/ P* l( x8 [, g' o
  30. 1 _. [8 R2 ~! g; N' O$ \1 B
  31.   /* 关闭JPEG所有中断 */
    & B- c4 e5 t1 y# d! T4 i* w" n  C; E
  32.   __HAL_JPEG_DISABLE_IT(hjpeg,JPEG_INTERRUPT_MASK);5 e) u5 B4 d( Q2 L" M
  33. 1 l6 k' G# m- I
  34.   /* 清空输入输入FIFO缓冲 */5 N1 U6 q) w) @, g6 M
  35.   hjpeg->Instance->CR |= JPEG_CR_IFF;1 a% y2 u+ C% }  y$ X. O2 G
  36.   hjpeg->Instance->CR |= JPEG_CR_OFF;  
    , W- w, |/ ^# X" \3 R
  37. 7 ]2 I+ r* i: }! \6 i
  38.   /* 清除所有标志 */, e9 n, e: U; H3 i2 L
  39.   __HAL_JPEG_CLEAR_FLAG(hjpeg,JPEG_FLAG_ALL);" t( W) g& M" g6 d5 m/ W  F

  40. - i7 `5 ]+ V" n, j- S5 R$ [. h0 |
  41.   /* 初始化默认的量化表 */
    5 q- S0 ~, H9 m
  42.   hjpeg->QuantTable0 = (uint8_t *)((uint32_t)JPEG_LUM_QuantTable);
    , E: o4 [" E0 _  h; T! j) X
  43.   hjpeg->QuantTable1 = (uint8_t *)((uint32_t)JPEG_CHROM_QuantTable);7 y$ i$ T9 d' [7 s0 A' Y* ]
  44.   hjpeg->QuantTable2 = NULL;
    5 D6 u9 o& s: L3 \3 D
  45.   hjpeg->QuantTable3 = NULL;9 C4 K( p% Z5 T/ `

  46. $ Z9 N+ `: s, h# @+ k* J
  47.   /* 初始化默认的霍夫曼表 */& G8 r5 c: j" p" y; I
  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)5 ]. [, O  ?! L0 {5 o
  49.   {
    . n$ q0 R1 i. T" A5 h/ `
  50.     hjpeg->ErrorCode = HAL_JPEG_ERROR_HUFF_TABLE;6 B1 V6 l$ a% t! F6 m6 e' w( \
  51. . B1 k& w3 G9 T; P
  52.     return HAL_ERROR;
    8 o) i) B$ ~) u( {
  53.   }
      U  ]( ^! ^. I" L; z4 D

  54. 9 @: G# ]- @5 @3 v
  55.   /* 使能文件头处理 */
    - ~* ^0 ^( {3 j# b! _6 t* y  m
  56.   hjpeg->Instance->CONFR1 |= JPEG_CONFR1_HDR;6 ]+ B3 A( J6 D
  57. $ A0 e# l) u  q: p
  58.   /* 复位JPEG输入输出计数 */
    3 v/ C1 N2 d  |' @) U# k. U2 Y/ ?/ v
  59.   hjpeg->JpegInCount = 0;* c2 T' J4 R0 n8 x; C; K( T+ [7 x# y
  60.   hjpeg->JpegOutCount = 0;  d$ l( Z$ d- h) O7 g2 Y, l
  61. / _' d8 H# b1 J3 R# I: {$ g) r0 E
  62.   /* 设置JPEG就绪 */. m% U+ w1 K: Z. l) F5 C
  63.   hjpeg->State = HAL_JPEG_STATE_READY;
    1 ~/ H& _3 j3 c; K5 g: y9 T

  64. 9 O+ U! N+ K. C7 r
  65.   /* 设置无错误 Reset the JPEG ErrorCode */& o9 E3 `/ e; S7 c. X) }1 L6 ?4 }" _
  66.   hjpeg->ErrorCode = HAL_JPEG_ERROR_NONE;' L5 d3 G7 s* \- P) ]

  67. & p  e+ a7 c8 u! N% S# i: N
  68.   /* 清除上下文 */
    : Y5 _8 q  o- j5 U: K, a
  69.   hjpeg->Context = 0;" {, m  n/ R, j, J" a. A
  70.   W2 j' t" z' I8 y
  71.   /* 返回HAL_OK */) d! `+ p; n1 V) u6 \* N( c
  72.   return HAL_OK;4 U7 d- f! N/ t3 ~! m
  73. }" v& e3 S$ q* L4 I& Z

  74. 9 T; S' Y8 z7 U) {
复制代码

! Z9 i1 k# H. x; }  ^& N8 w函数描述:3 j) }$ g$ O! K
' o) B9 G5 \! L. N% M; Z
此函数用于初始化JPEG。
1 d3 r! k/ Y8 d/ W- G
7 `+ M! c1 q( ^函数参数:' t+ X  f; l6 n3 x2 B7 r
# G3 G) h( }' O6 s, y: p
  第1个参数是JPEG_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数,结构体变量成员的详细介绍看本章3.3小节。
8 p! z" M/ d* b7 y) }  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。5 _) L' ?2 z- d' x. a
注意事项:
0 b1 Q7 @+ G' y4 V( }5 k. L' O# r
函数HAL_JPEG_MspInit用于初始化JPEG的底层时钟、NVIC等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的,允许用户在工程其它源文件里面重新实现此函数。当然,不限制一定要在此函数里面实现,也可以像早期的标准库那样,用户自己初始化即可,更灵活些。: L* _5 _9 J! Y% X
如果形参hjpeg的结构体成员State没有做初始状态,这个地方就是个坑。特别是用户搞了一个局部变量JPEG_HandleTypeDef JpegHandle。
4 e6 W+ O: m& r9 ^对于局部变量来说,这个参数就是一个随机值,如果是全局变量还好,一般MDK和IAR都会将全部变量初始化为0,而恰好这个 HAL_JPEG_STATE_RESET  = 0x00U。! d% k9 S+ w& i, {- v1 N- q' Q3 p

; E2 y5 a) Z4 k2 o  ^; W0 F解决办法有三
4 V1 u$ n7 ^9 @) f
- \3 {9 U. u/ p. b" X2 Y  s方法1:用户自己初始JPEG底层。
- f+ F8 y4 R% T) e+ {$ a$ v, P4 C7 _# U( [/ e- w; C1 i
方法2:定义JPEG_HandleTypeDef JpegHandle为全局变量。6 n! v/ V$ y$ \/ w; `) W

' {$ I( q( T! @: j方法3:下面的方法3 X% H& f4 d! k1 _) P( z
1 E2 E) |( E& g# ]) J
  1. if(HAL_JPEG_DeInit(&JpegHandle) != HAL_OK)  N, r& Y3 {# N" _! G; D
  2. {) I5 o% s" J  ~1 M/ H5 D* `" i
  3.     Error_Handler();" A. g( B: g# W$ b3 o( ]3 Q. M9 E4 m
  4. }  6 y, z, d, J) e  e+ X5 ~
  5. if(HAL_JPEG_Init(&Dma2dHandle) != HAL_OK)
    ; o+ x/ _$ A& k
  6. {9 j3 m$ p9 W) Y" p
  7.     Error_Handler();
    0 u! t) h4 R  M& K, C8 i
  8. }
复制代码
6 \9 Z8 a0 E6 l9 _, C7 M' {
使用举例:
' d! e) L$ A7 b8 `
  1. JPEG_HandleTypeDef    JPEG_Handle;
    9 E( @' h% e$ F) J. n
  2. JPEG_Handle.Instance = JPEG;0 j, y' ]- t, o6 U" {+ n. e1 k
  3. HAL_JPEG_Init(&JPEG_Handle);
复制代码
# n8 W7 f! w: [; O* e7 `
57.4.2 函数HAL_JPEG_GetInfo8 r' f9 Y* Q/ D9 o( |$ M
函数原型:' \6 V6 e- t) U" z
$ @* v$ N( `. }
  1. HAL_StatusTypeDef HAL_JPEG_GetInfo(JPEG_HandleTypeDef *hjpeg, JPEG_ConfTypeDef *pInfo)
    / S" v& x5 s4 s2 C
  2. {- _0 b. Q* f) L- f
  3.   uint32_t yblockNb, cBblockNb, cRblockNb;
    ) J9 ^4 g5 C( x$ w) u

  4. 1 U* T# ~) ?8 l! z
  5.   /* 检测句柄是否有效 */6 E1 O! s/ W2 d5 u. p& ]' f
  6.   if((hjpeg == NULL) || (pInfo == NULL))1 D: Q/ N. ^( a- A7 M
  7.   {- x( |& Q7 d1 A- v, S: l7 h; l
  8.     return HAL_ERROR;+ k/ C- f  W; p* G
  9.   }+ s# k  w) B9 W8 }1 {7 M) R6 z$ R

  10.   V4 r: l+ B* G* T, N1 [0 h& Z
  11.   /* 读取配置参数 *// @$ k8 S) k) ^! t. {3 {* L4 T
  12.   if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF_1)2 W% A" P* ?1 Q2 w/ C1 a
  13.   {
    - d! b$ k/ U5 m  M/ g3 g1 }/ @
  14.     pInfo->ColorSpace = JPEG_YCBCR_COLORSPACE;   
      n3 v# B2 S  Y2 B+ ]
  15.   }    ( X/ l) O9 C$ n" u) R
  16.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == 0)
    / ^0 U$ H+ f8 d: [! h$ S$ P1 W
  17.   {
    ; ~" n. y8 Q+ ]0 `
  18.     pInfo->ColorSpace = JPEG_GRAYSCALE_COLORSPACE;
      b# M; l9 b  Z) M
  19.   }% A' e+ g/ }$ a) Q& d9 T" Y1 i
  20.   else if((hjpeg->Instance->CONFR1 & JPEG_CONFR1_NF) == JPEG_CONFR1_NF)
      E8 r- X. e6 ?
  21.   {
    ; Z4 V" Q6 B9 e
  22.     pInfo->ColorSpace = JPEG_CMYK_COLORSPACE;    + m+ R7 i0 a# H1 i
  23.   }
    ; E! }( `- }# T/ P, _; y
  24. 8 \  D# Z( U) R$ R
  25.   pInfo->ImageHeight = (hjpeg->Instance->CONFR1 & 0xFFFF0000U) >> 16;, W! s  \# T5 N' F0 L+ M' l1 a& h
  26.   pInfo->ImageWidth  = (hjpeg->Instance->CONFR3 & 0xFFFF0000U) >> 16;
    8 B: S9 q% H# K' q  f' I4 ?- U

  27. ! j+ y2 w; l5 N+ L& {: E6 P
  28.   if((pInfo->ColorSpace == JPEG_YCBCR_COLORSPACE) || (pInfo->ColorSpace == JPEG_CMYK_COLORSPACE))
    1 @9 e3 Y1 H; g% n
  29.   {
    & \" e! ]3 t2 A1 d2 B
  30.     yblockNb  = (hjpeg->Instance->CONFR4 & JPEG_CONFR4_NB) >> 4;
    ' D+ b% J% a7 L  D' ^$ x5 D* D) K
  31.     cBblockNb = (hjpeg->Instance->CONFR5 & JPEG_CONFR5_NB) >> 4;4 S+ U2 R" W; e6 w
  32.     cRblockNb = (hjpeg->Instance->CONFR6 & JPEG_CONFR6_NB) >> 4;1 x7 h$ t$ G! y& R0 ~

  33. $ N5 i6 r+ K  L8 [
  34.     if((yblockNb == 1) && (cBblockNb == 0) && (cRblockNb == 0))
    , v! f8 m* J' N  Y# H$ Q8 t
  35.     {
    ! y  l2 S2 h$ q4 U; Y
  36.       pInfo->ChromaSubsampling = JPEG_422_SUBSAMPLING; /*16x8 block*/# i) A" g: n$ v+ J2 S$ U" _5 O
  37.     }4 t" k1 B. W6 p# S4 i0 |, E1 E1 u
  38.     else if((yblockNb == 0) && (cBblockNb == 0) && (cRblockNb == 0))3 J( c4 O4 P  p
  39.     {' m; `3 x  H* B* j  [/ c0 X; T
  40.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    # `, B6 I5 J( R: b7 V! z
  41.     }* t! s; ~5 E$ e. R  i0 O
  42.     else if((yblockNb == 3) && (cBblockNb == 0) && (cRblockNb == 0))
    . S/ k' P0 D; S5 a) Y
  43.     {, O1 H# j. V8 O  _2 i7 k9 p
  44.       pInfo->ChromaSubsampling = JPEG_420_SUBSAMPLING;3 F% t8 U3 q, V
  45.     }
    " x9 j/ D5 e! K: H# I( K
  46.     else /* 默认是 4:4:4*/1 D0 f) ~1 d3 i% h1 U
  47.     {/ |; B2 r! Q  K2 o8 J3 }
  48.       pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    5 t3 i& h) D5 i  _8 e" Y: |/ b+ W
  49.     }
    $ h! f+ B$ o: D( Q, [
  50.   }
    5 a( o! p0 R% j9 }7 E% r. {4 i
  51.   else
    3 F( m1 f* m3 f; T' o' x
  52.   {
    & U3 t. ~# D/ w) @' L
  53.     pInfo->ChromaSubsampling = JPEG_444_SUBSAMPLING;
    $ S$ D( t( w; B
  54.   }, r5 M# v8 ?( v! u& H! \. Z6 M

  55. ( v) R  y' J, N; L2 V) J5 |
  56.   pInfo->ImageQuality = JPEG_GetQuality(hjpeg);
    7 w$ E3 W4 W7 @

  57. 0 d7 S" F' P; n5 C
  58.   /* 返回HAL_OK */0 i. {6 i( z7 C  I* b& a% L
  59.   return HAL_OK;
    , f! e$ r1 i" @" e8 L$ g  e4 ~( M
  60. }
    & e5 C+ W% h1 v! k7 j2 E
复制代码

% X8 S& ^, M0 {( K& R函数描述:
2 S% I# l, [) ^# B6 J0 i7 e4 r$ i2 @
此函数主要用于解码JPEG时获取相关图像信息,比如图像质量,图像长宽等。
+ h; a1 M) x4 p5 D2 h8 n, G: h: @: ]7 \& A1 S6 {8 E
函数参数:! u6 U  L! n& I( W/ ?

% l/ h0 o2 t. m* _  第1个参数是JPEG_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数,结构体变量成员的详细介绍看本章3.3小节。
* g9 @# q0 J( ^. C  O  第2个参数是JPEG_ConfTypeDef类型结构体指针变量,用于获取JPEG的配置信息,结构体变量成员的详细介绍看本章3.2小0 K4 V1 a5 r, V: `6 @% G5 ~
  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。# j1 y. B* F* Z* ~
  d' J; z7 m8 L& t
) x, }* L+ Q5 N' T
使用举例:
$ S/ Y4 ]1 |' E' {
  1. JPEG_HandleTypeDef    JPEG_Handle;3 }; i( x( @, C7 t# c" S: K' N* v
  2. JPEG_ConfTypeDef      JPEG_Info;( z& |! s1 ]9 J& s+ Z4 _

  3. 3 C" L' N0 n6 e- g
  4. HAL_JPEG_GetInfo(&JPEG_Handle, &JPEG_Info);  
复制代码

& }/ d9 e% D: B3 X: O0 v" F8 P57.4.3 函数HAL_JPEG_Decode_DMA
7 _; W( X1 @% [' I! P% N1 J函数原型:' m2 y) Y; }! a8 w# @

# P2 y  Z7 m" S& ^2 d
  1. HAL_StatusTypeDef  HAL_JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg ,uint8_t *pDataIn ,uint32_t InDataLength ,uint8_t *pDataOutMCU ,uint32_t OutDataLength): u9 F; ^: m7 X( f- J
  2. {
    & R/ v7 _3 u% }2 k
  3.   /* 检测参数 */
    , U2 Y2 z( [' F; r8 B$ D
  4.   assert_param((InDataLength >= 4));& Z+ L7 T  C6 j$ A" A2 j* U
  5.   assert_param((OutDataLength >= 4));
    7 |9 @" ^7 `6 j! @0 h+ B. L

  6. 2 h2 c* v) N9 }; m4 K+ ~4 M
  7.   /* 检测参数 */
    2 i4 k3 [3 [2 _& W
  8.   if((hjpeg == NULL) || (pDataIn == NULL) || (pDataOutMCU == NULL))
    2 t1 `# V5 |5 R; P* U4 L
  9.   {8 X6 x3 o4 b+ s. y
  10.     return HAL_ERROR;
    8 n! k( X% I7 V" G0 M  x, H
  11.   }
    , u5 ~- v& E2 B: ~' q: P. L! h
  12. 0 h) r$ y3 k, h1 J
  13.   /* 上锁 */! Y  K2 h% S( j# y. U: e
  14.   __HAL_LOCK(hjpeg);
    9 r- E4 W! |4 b
  15. + A# `, M: f- F
  16.   if(hjpeg->State == HAL_JPEG_STATE_READY)
    ' U* t' r0 [2 I% v6 ^2 b. @, Y
  17.   {
      y( R6 d) v0 `' l( e' {$ q
  18.     /* 设置JPEG忙 */
    9 Z* L0 x1 g& k8 n
  19.     hjpeg->State = HAL_JPEG_STATE_BUSY_DECODING;
    6 J. H6 j& s3 W: ?0 k( ]! W

  20. - i9 E: ^- f( B3 q( Y. W
  21.     /* 设置JPEG上下文,工作在DMA界面状态 */# M$ M3 ^, k6 h) y6 f
  22.     hjpeg->Context &= ~(JPEG_CONTEXT_OPERATION_MASK | JPEG_CONTEXT_METHOD_MASK);
    3 z- K3 T1 |! I/ }. g! m. K
  23.     hjpeg->Context |= (JPEG_CONTEXT_DECODE | JPEG_CONTEXT_DMA);         ) \3 _! f2 ]: ~1 v* H! s

  24. # a& |9 E7 j6 X( }, b, V- A
  25.     /* 设置输入输出缓冲地址和大小 */- y* v# i$ V7 {3 P4 s( `
  26.     hjpeg->pJpegInBuffPtr = pDataIn;
    2 w: y( D6 o- M% ]' g
  27.     hjpeg->pJpegOutBuffPtr = pDataOutMCU;
    * L% Q3 b% U$ G# v# n
  28.     hjpeg->InDataLength = InDataLength;
    ' Y3 |& I' x; s& W; ^- M% h
  29.     hjpeg->OutDataLength = OutDataLength;
    7 v* j, u) v, @  }

  30. ' a) w7 \1 t; |  s
  31.     /* 复位输入输出缓冲计数 */
    4 h; l3 m4 w8 `  j
  32.     hjpeg->JpegInCount = 0;   
    ; g, {( H9 R6 F8 N
  33.     hjpeg->JpegOutCount = 0;   
    0 R6 w5 _0 e& Z! k

  34. ) H1 \" c' e/ g" k/ i5 N7 T
  35.     /* 初始化解码处理 */5 y. j' s) K, c6 h) R
  36.     JPEG_Init_Process(hjpeg);6 E- B) W: Y7 F) l2 V. w

  37. 1 ^- ^4 }, U. ^; N5 Z4 Y0 B
  38.     /* 启动JPEG解码处理,使用DMA方式 */2 v" B, E* [3 `! ~8 C
  39.     JPEG_DMA_StartProcess(hjpeg);; {! D2 a/ U5 C0 n
  40. + c$ ]; m+ c% z. U% F
  41.   }+ v2 J4 G9 t, E+ o0 B
  42.   else6 i/ d. h$ w0 Q( D1 H
  43.   {* j, [+ u# s6 G7 @0 Q4 C
  44.     /* 解锁 */: Y" b3 l  n0 l& z/ T$ [
  45.     __HAL_UNLOCK(hjpeg);
    + B( c9 S3 V, M& g
  46. , S! m) t- P; x1 r  A
  47.     return HAL_BUSY;* O; s) j: J7 h' p0 i
  48.   }5 @0 M) p7 ~4 l
  49. $ u9 p& R  J) M/ ~! M% q
  50.   /* 返回HAL_OK */- M. n* ?2 n% |8 G9 {! W. j
  51.   return HAL_OK;
    / g6 A+ R0 G! W+ k( z$ L
  52. }6 V7 H& ]0 L4 y; J9 L7 E
复制代码
, z$ U% `/ F. S! A( x; `- d/ P

: d1 u  y" E* C+ E4 M2 s/ I函数描述:4 K" S' m9 n, \4 C
# H0 c1 A2 v3 z
此函数用于启动JPEG的DMA方式解码。
* K* N$ u; k; s) Z  w$ Z0 B6 h7 ~3 v$ }
( m. N( g8 O% Q+ E+ ?1 ]( I  O函数参数:8 Q/ P% Y/ R  l3 |5 d7 K$ l4 a
$ f4 [1 Y* V; Y+ w0 T; c
  第1个参数是JPEG_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数,结构体变量成员的详细介绍看本章3.3小节。
1 c( i8 H6 a/ h4 t% E, x# N  第2个参数是输入数据缓冲地址。+ V) N% ^8 O2 W2 v# K9 }( ]1 Z
  第3个参数输入数据大小,单位字节。
9 q5 u8 S- E" x. s2 G- e8 T- m  第4个参数是输出缓冲地址。
) g) [) `+ P% }1 }  第5个参数是输出缓冲大小,单位字节。
4 g2 X- P& W5 x. n0 Y  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
: }  o5 V7 r0 A  |4 @* I
3 ~7 \9 c+ h3 i$ t- G3 i% b使用举例:5 R1 E8 v% D* O" |

9 d3 D" V: c$ f0 r
  1. /*
    # d  @$ U" X( W2 m# E
  2. *********************************************************************************************************4 m  @9 t% v& M% F
  3. *    函 数 名: JPEG_Decode_DMA
    * W$ d3 {+ f2 a$ ~( X
  4. *    功能说明: JPEG解码$ }: c- r1 {& }) @
  5. *    形    参: hjpeg               JPEG_HandleTypeDef句柄指针3 _2 [5 q- ?/ w, Z' W' J' n
  6. *             FrameSourceAddress  数据地址6 \# n5 I, X* B  @7 v! W
  7. *             FrameSize           数据大小8 W$ J1 K: F. g: e
  8. *             DestAddress         目的数据地址. _5 j1 N8 g3 U- T
  9. *    返 回 值: HAL_ERROR表示配置失败,HAL_OK表示配置成功9 I& n, E7 Z. e7 j- {) ^4 d9 t3 Z
  10. *             HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出
    8 ?: B+ E2 m- _+ ?2 R6 g. i
  11. *********************************************************************************************************' R* K& o8 \) C3 e, D2 C# w
  12. */
    / r9 Z  |4 L- l/ b. n% R
  13. uint32_t JPEG_Decode_DMA(JPEG_HandleTypeDef *hjpeg, uint32_t FrameSourceAddress ,uint32_t FrameSize, uint32_t DestAddress)* R* Q$ ^( Y' e' G& ]6 @, T
  14. {
    7 F+ M) i0 X3 ?, d
  15.     JPEGSourceAddress =  FrameSourceAddress ;
    9 q7 ^8 O" t0 T+ l6 A* c7 F
  16.     FrameBufferAddress = DestAddress;; @* w6 O2 m( m+ m  v* g* u+ C
  17.     Input_frameIndex = 0;' r$ U$ Q. E! r$ [8 K
  18.     Input_frameSize = FrameSize;
    ' Q* |2 x1 M7 A0 Z8 n$ C
  19. $ D0 j; @. z& v
  20.     /* 设置标志,0表示开始解码,1表示解码完成 */# i' ^* @$ ?- v( y, i
  21.     Jpeg_HWDecodingEnd = 0;
    " K: R- ]( l5 h' H/ r
  22. # ]8 u+ J2 g# \$ D& W
  23.     /* 启动JPEG解码 */0 L7 a$ U8 W6 N
  24.     HAL_JPEG_Decode_DMA(hjpeg ,(uint8_t *)JPEGSourceAddress ,CHUNK_SIZE_IN ,  a! h8 I) l% g/ }$ [, R- W. C& }: B' H
  25. (uint8_t *)FrameBufferAddress ,CHUNK_SIZE_OUT);
    8 U# @& N4 H) I
  26. - y, P* I3 h; R: H8 E( ]
  27.     return HAL_OK;
    3 x9 r8 C; A' a  T
  28. }
复制代码
8 D4 ]6 J. ]+ S4 y  i
57.4.4 函数HAL_JPEG_ConfigInputBuffer/ i5 b. a% n8 W4 i6 B
函数原型:+ u2 t3 Q; w* {4 Z
1 {$ w0 t' A) C' i$ v! Y1 }
  1. void HAL_JPEG_ConfigInputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewInputBuffer, uint32_t InDataLength); v- H" u! w$ r. c; a: d
  2. {6 ^2 M; b' F) H
  3.   hjpeg->pJpegInBuffPtr =  pNewInputBuffer;
    ) m1 s" d2 s% H' z; \7 i7 j
  4.   hjpeg->InDataLength = InDataLength;
    ! a6 x+ ^7 y+ l
  5. }
复制代码

" A/ K6 T- K% ^7 l& l* k) ~9 ?% T6 R函数描述:
: O( \3 b2 L: a6 Q/ ~; }, Q2 b  D2 o8 g, l- Z8 s* f( J  Q
此函数用于配置编解码输入缓冲地址和数据大小。
1 e3 p9 ^3 {% {% A3 N
3 \" X2 S3 M5 P1 C/ i& I# n( P函数参数:
# b, Y/ C: C2 l
; x( f0 b5 ~8 t# a& ?0 n  第1个参数是JPEG_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数,结构体变量成员的详细介绍看本章3.3小节。4 g( Y& |6 H: p1 g% k# E3 B0 E
  第2个参数是输入缓冲地址。- j- p  Y1 s5 F  x3 \
  第3个参数是输入缓冲大小,单位字节。
7 P& M. u+ D! `! p  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
6 t! s2 t+ |% U, Q+ W+ V" Q$ ?1 {9 D使用举例:5 H0 A3 T1 \  ]$ h1 l
6 }" F( ]; @6 g) s3 z) l
  1. /*
    " Y- G$ Z4 R% ]' J
  2. *********************************************************************************************************
    ' b/ R4 |' ]6 L6 O8 _! W% e  F" L* @
  3. *    函 数 名: HAL_JPEG_GetDataCallback9 ^; Z' L, V) N1 m. \7 Q# t
  4. *    功能说明: JPEG回调函数,用于从输入地址获取新数据继续解码0 z7 r. A( X5 `" V
  5. *    形    参: hjpeg          JPEG_HandleTypeDef 句柄指针
      s0 U- z2 _7 J' Q4 g
  6. *             NbDecodedData  上一轮已经解码的数据大小,单位字节  & a" \3 ~6 k$ u/ u
  7. *    返 回 值: 无
    ) @& p* e2 @: d; S
  8. *********************************************************************************************************4 S6 U2 o* J4 W9 ~( [  d9 ^
  9. */
      B3 Z4 G7 l1 j1 S
  10. void HAL_JPEG_GetDataCallback(JPEG_HandleTypeDef *hjpeg, uint32_t NbDecodedData)1 V0 U( l1 n# _, X7 F
  11. {7 z% }" s5 f+ u+ {% S6 y
  12.     uint32_t inDataLength;
    4 }* R7 g3 n( K8 w

  13. " R' m& O6 A7 ]: M* Z
  14.     /* 更新已经解码的数据大小 */6 b( m2 S/ A2 N7 q9 f
  15.     Input_frameIndex += NbDecodedData;$ j6 Y' j( J  X0 L+ y
  16. 4 S* r- c. a, g0 t/ p
  17.     /* 如果当前已经解码的数据小于总文件大小,继续解码 */3 p0 H6 O3 a# {' \
  18.     if( Input_frameIndex < Input_frameSize)
    6 B! m2 B* {3 O* w' n
  19.     {( b, i4 ~/ Z3 e: D( P" [( C
  20.         /* 更新解码数据位置 */& Z- G$ f# F1 z$ M$ h
  21.         JPEGSourceAddress = JPEGSourceAddress + NbDecodedData;5 _( k7 U$ A0 K# k* Y7 I7 f' W
  22. ; r1 `0 r! c1 t6 i4 ~2 _6 I; V
  23.         /* 更新下一轮要解码的数据大小 */
    8 b0 ~+ ^* T, v+ u
  24.         if((Input_frameSize - Input_frameIndex) >= CHUNK_SIZE_IN)) @; x& K7 _9 X# U( Q: B5 y0 y3 h
  25.         {
    1 {, l6 d6 H0 E8 z& v
  26.             inDataLength = CHUNK_SIZE_IN;+ _7 e4 J% @' P; R4 w! s# O
  27.         }7 ?: q) L" [7 o' @8 V- T: A
  28.         else( y1 j7 H2 q3 }2 y% G
  29.         {
    + t9 P# @% h$ G4 W6 w2 j3 n: Q
  30.             inDataLength = Input_frameSize - Input_frameIndex;
    + U- v: C: B( h* a/ x, l8 P
  31.         }   
    8 m0 I* e0 e+ B6 \/ l: v" t/ K
  32.     }
    3 [6 M5 x$ A6 L7 H: F  i- D
  33.     else3 i0 T( l! N. Y& S
  34.     {2 U  f' Z1 `& h2 g0 z- W! i
  35.         inDataLength = 0;
    % A9 L' v/ B  e, [' \! B# P
  36.     }* K  I0 F: z1 \# {4 M  }& P
  37. 8 T# P4 \, H; R# [# x7 p0 e
  38.     /* 更新输入缓冲 */
    - r$ G9 ~. h" V
  39.     HAL_JPEG_ConfigInputBuffer(hjpeg,(uint8_t *)JPEGSourceAddress, inDataLength);   
    8 E2 F. e0 L5 s/ {
  40. }
复制代码
0 {' E, J, Z, J+ ~8 ?

) g9 E; M- w5 u0 x) p# \. b2 L5 L% t57.4.5 函数HAL_JPEG_ConfigOutputBuffer/ P! z: m' a5 c* d, w0 }' [) x/ \$ J
函数原型:  X+ g: r1 t6 c" z% z  D2 Z$ p

1 O7 [5 s% U/ _+ W
  1. void HAL_JPEG_ConfigOutputBuffer(JPEG_HandleTypeDef *hjpeg, uint8_t *pNewOutputBuffer, uint32_t OutDataLength)
    ) r5 H% \8 q$ l, L2 I
  2. {
    : s; B* c' a6 j; A+ N/ A
  3.   hjpeg->pJpegOutBuffPtr = pNewOutputBuffer;
    & r( w8 v9 Q) L6 U
  4.   hjpeg->OutDataLength = OutDataLength;  # @7 V# ?! P( d
  5. }
复制代码

0 b5 ~' X5 s6 u5 ]9 U$ l, H' g9 h7 b: L4 {& X  q  ^
函数描述:
8 f5 o8 }, P- r5 Z( [! h; k6 d5 c- G+ A5 ^* D8 C, ~: K
此函数用于配置编解码输出缓冲地址和数据大小。
2 l4 h/ d& d2 P+ h, f! i2 J; S- d* D1 t; I
函数参数:) R5 H# Z5 e4 U  k# f

# v. z3 ~( A/ V) A* @& p  第1个参数是JPEG_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数,结构体变量成员的详细介绍看本章3.3小节。
6 d3 c, t5 A/ _; D1 a; g( b- e  第2个参数是输出缓冲地址。% t; x- e2 ]; R, I$ f# s, Z. W  e& M
  第3个参数是输出缓冲大小,单位字节。
& ^7 I) y5 I0 p  返回值,返回HAL_ERROR表示配置失败,HAL_OK表示配置成功,HAL_BUSY表示忙(操作中),HAL_TIMEOUT表示时间溢出。
9 i" Y6 R/ O2 S使用举例:, k. ^4 ]. W& O0 R$ Y" X

) k4 ]1 V. Y4 l& R
  1. /*
    ! c& r+ u( g! E0 m
  2. *********************************************************************************************************
    - _% ~9 M) L9 L  x
  3. *    函 数 名: HAL_JPEG_DataReadyCallback
    3 {1 Z$ m& z# Z$ }6 T4 C
  4. *    功能说明: JPEG回调函数,用于输出缓冲地址更新5 M4 @# X2 q8 G9 ^- D
  5. *    形    参: hjpeg         JPEG_HandleTypeDef 句柄指针
    * Z* W) S- ~7 x; v
  6. *             pDataOut      输出数据缓冲, V3 \8 q$ Y8 [; H
  7. *             OutDataLength 输出数据大小,单位字节
      m; k$ v( }- v
  8. *    返 回 值: 无. c: _  K& P1 O" n  k
  9. *********************************************************************************************************, M( P+ b3 b- B% _2 U/ }- j/ h8 G. t, s
  10. */
    " n7 W! F% q+ B) [
  11. void HAL_JPEG_DataReadyCallback (JPEG_HandleTypeDef *hjpeg, uint8_t *pDataOut, uint32_t OutDataLength)
    3 N3 y, a& ?* G" w( R' O
  12. {( u, t- V1 [% P5 }9 o3 h6 _- N
  13.     /* 更新JPEG输出地址 */  2 J& f: C6 W# _0 m1 }' _
  14.     FrameBufferAddress += OutDataLength;+ g0 g6 _) O$ l/ b1 O% ?" N( S
  15. $ F5 h  E( P7 h# X/ W5 I
  16.     HAL_JPEG_ConfigOutputBuffer(hjpeg, (uint8_t *)FrameBufferAddress, CHUNK_SIZE_OUT);
    3 }+ Z2 e3 v4 L7 o7 |
  17. }
复制代码
, z2 E; d+ E' p2 ~* J* T
57.5 总结4 l- U* u, n- F1 z2 p
本章节就为大家讲解这么多,JPEG功能用到的地方还是比较多的,建议熟练使用。
; z- c/ T0 m1 L+ K$ l2 L0 Z" b5 g4 p/ @; F7 D6 B

' r5 V/ g# Z( m% h) Z1 x' V
. U5 I8 l- [5 Y; R
赞 收藏 评论0 发布时间:2021-12-21 21:46

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版