1#![allow(clippy::missing_safety_doc)]
2#![allow(clippy::identity_op)]
3#![allow(clippy::unnecessary_cast)]
4#![allow(clippy::erasing_op)]
5
6#[doc = "JPEG codec"]
7#[derive(Copy, Clone, Eq, PartialEq)]
8pub struct Jpeg {
9 ptr: *mut u8,
10}
11unsafe impl Send for Jpeg {}
12unsafe impl Sync for Jpeg {}
13impl Jpeg {
14 #[inline(always)]
15 pub const unsafe fn from_ptr(ptr: *mut ()) -> Self {
16 Self { ptr: ptr as _ }
17 }
18 #[inline(always)]
19 pub const fn as_ptr(&self) -> *mut () {
20 self.ptr as _
21 }
22 #[doc = "JPEG codec configuration register 0"]
23 #[inline(always)]
24 pub const fn jpeg_confr0(self) -> crate::common::Reg<regs::JpegConfr0, crate::common::W> {
25 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0usize) as _) }
26 }
27 #[doc = "JPEG codec configuration register 1"]
28 #[inline(always)]
29 pub const fn jpeg_confr1(self) -> crate::common::Reg<regs::JpegConfr1, crate::common::RW> {
30 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04usize) as _) }
31 }
32 #[doc = "JPEG codec configuration register 2"]
33 #[inline(always)]
34 pub const fn jpeg_confr2(self) -> crate::common::Reg<regs::JpegConfr2, crate::common::RW> {
35 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x08usize) as _) }
36 }
37 #[doc = "JPEG codec configuration register 3"]
38 #[inline(always)]
39 pub const fn jpeg_confr3(self) -> crate::common::Reg<regs::JpegConfr3, crate::common::RW> {
40 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0cusize) as _) }
41 }
42 #[doc = "JPEG codec configuration register 4"]
43 #[inline(always)]
44 pub const fn jpeg_confr4(self) -> crate::common::Reg<regs::JpegConfr4, crate::common::RW> {
45 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x10usize) as _) }
46 }
47 #[doc = "JPEG codec configuration register 5"]
48 #[inline(always)]
49 pub const fn jpeg_confr5(self) -> crate::common::Reg<regs::JpegConfr5, crate::common::RW> {
50 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x14usize) as _) }
51 }
52 #[doc = "JPEG codec configuration register 6"]
53 #[inline(always)]
54 pub const fn jpeg_confr6(self) -> crate::common::Reg<regs::JpegConfr6, crate::common::RW> {
55 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x18usize) as _) }
56 }
57 #[doc = "JPEG codec configuration register 7"]
58 #[inline(always)]
59 pub const fn jpeg_confr7(self) -> crate::common::Reg<regs::JpegConfr7, crate::common::RW> {
60 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x1cusize) as _) }
61 }
62 #[doc = "JPEG control register"]
63 #[inline(always)]
64 pub const fn jpeg_cr(self) -> crate::common::Reg<regs::JpegCr, crate::common::RW> {
65 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x30usize) as _) }
66 }
67 #[doc = "JPEG status register"]
68 #[inline(always)]
69 pub const fn jpeg_sr(self) -> crate::common::Reg<regs::JpegSr, crate::common::R> {
70 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x34usize) as _) }
71 }
72 #[doc = "JPEG clear flag register"]
73 #[inline(always)]
74 pub const fn jpeg_cfr(self) -> crate::common::Reg<regs::JpegCfr, crate::common::W> {
75 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x38usize) as _) }
76 }
77 #[doc = "JPEG data input register"]
78 #[inline(always)]
79 pub const fn jpeg_dir(self) -> crate::common::Reg<regs::JpegDir, crate::common::W> {
80 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x40usize) as _) }
81 }
82 #[doc = "JPEG data output register"]
83 #[inline(always)]
84 pub const fn jpeg_dor(self) -> crate::common::Reg<regs::JpegDor, crate::common::R> {
85 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x44usize) as _) }
86 }
87 #[doc = "JPEG quantization tables"]
88 #[inline(always)]
89 pub const fn qmem0_0(self) -> crate::common::Reg<regs::Qmem00, crate::common::RW> {
90 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x50usize) as _) }
91 }
92 #[doc = "JPEG quantization tables"]
93 #[inline(always)]
94 pub const fn qmem0_1(self) -> crate::common::Reg<regs::Qmem01, crate::common::RW> {
95 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x54usize) as _) }
96 }
97 #[doc = "JPEG quantization tables"]
98 #[inline(always)]
99 pub const fn qmem0_2(self) -> crate::common::Reg<regs::Qmem02, crate::common::RW> {
100 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x58usize) as _) }
101 }
102 #[doc = "JPEG quantization tables"]
103 #[inline(always)]
104 pub const fn qmem0_3(self) -> crate::common::Reg<regs::Qmem03, crate::common::RW> {
105 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x5cusize) as _) }
106 }
107 #[doc = "JPEG quantization tables"]
108 #[inline(always)]
109 pub const fn qmem0_4(self) -> crate::common::Reg<regs::Qmem04, crate::common::RW> {
110 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x60usize) as _) }
111 }
112 #[doc = "JPEG quantization tables"]
113 #[inline(always)]
114 pub const fn qmem0_5(self) -> crate::common::Reg<regs::Qmem05, crate::common::RW> {
115 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x64usize) as _) }
116 }
117 #[doc = "JPEG quantization tables"]
118 #[inline(always)]
119 pub const fn qmem0_6(self) -> crate::common::Reg<regs::Qmem06, crate::common::RW> {
120 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x68usize) as _) }
121 }
122 #[doc = "JPEG quantization tables"]
123 #[inline(always)]
124 pub const fn qmem0_7(self) -> crate::common::Reg<regs::Qmem07, crate::common::RW> {
125 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x6cusize) as _) }
126 }
127 #[doc = "JPEG quantization tables"]
128 #[inline(always)]
129 pub const fn qmem0_8(self) -> crate::common::Reg<regs::Qmem08, crate::common::RW> {
130 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x70usize) as _) }
131 }
132 #[doc = "JPEG quantization tables"]
133 #[inline(always)]
134 pub const fn qmem0_9(self) -> crate::common::Reg<regs::Qmem09, crate::common::RW> {
135 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x74usize) as _) }
136 }
137 #[doc = "JPEG quantization tables"]
138 #[inline(always)]
139 pub const fn qmem0_10(self) -> crate::common::Reg<regs::Qmem010, crate::common::RW> {
140 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x78usize) as _) }
141 }
142 #[doc = "JPEG quantization tables"]
143 #[inline(always)]
144 pub const fn qmem0_11(self) -> crate::common::Reg<regs::Qmem011, crate::common::RW> {
145 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x7cusize) as _) }
146 }
147 #[doc = "JPEG quantization tables"]
148 #[inline(always)]
149 pub const fn qmem0_12(self) -> crate::common::Reg<regs::Qmem012, crate::common::RW> {
150 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x80usize) as _) }
151 }
152 #[doc = "JPEG quantization tables"]
153 #[inline(always)]
154 pub const fn qmem0_13(self) -> crate::common::Reg<regs::Qmem013, crate::common::RW> {
155 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x84usize) as _) }
156 }
157 #[doc = "JPEG quantization tables"]
158 #[inline(always)]
159 pub const fn qmem0_14(self) -> crate::common::Reg<regs::Qmem014, crate::common::RW> {
160 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x88usize) as _) }
161 }
162 #[doc = "JPEG quantization tables"]
163 #[inline(always)]
164 pub const fn qmem0_15(self) -> crate::common::Reg<regs::Qmem015, crate::common::RW> {
165 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x8cusize) as _) }
166 }
167 #[doc = "JPEG quantization tables"]
168 #[inline(always)]
169 pub const fn qmem1_0(self) -> crate::common::Reg<regs::Qmem10, crate::common::RW> {
170 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x90usize) as _) }
171 }
172 #[doc = "JPEG quantization tables"]
173 #[inline(always)]
174 pub const fn qmem1_1(self) -> crate::common::Reg<regs::Qmem11, crate::common::RW> {
175 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x94usize) as _) }
176 }
177 #[doc = "JPEG quantization tables"]
178 #[inline(always)]
179 pub const fn qmem1_2(self) -> crate::common::Reg<regs::Qmem12, crate::common::RW> {
180 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x98usize) as _) }
181 }
182 #[doc = "JPEG quantization tables"]
183 #[inline(always)]
184 pub const fn qmem1_3(self) -> crate::common::Reg<regs::Qmem13, crate::common::RW> {
185 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x9cusize) as _) }
186 }
187 #[doc = "JPEG quantization tables"]
188 #[inline(always)]
189 pub const fn qmem1_4(self) -> crate::common::Reg<regs::Qmem14, crate::common::RW> {
190 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xa0usize) as _) }
191 }
192 #[doc = "JPEG quantization tables"]
193 #[inline(always)]
194 pub const fn qmem1_5(self) -> crate::common::Reg<regs::Qmem15, crate::common::RW> {
195 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xa4usize) as _) }
196 }
197 #[doc = "JPEG quantization tables"]
198 #[inline(always)]
199 pub const fn qmem1_6(self) -> crate::common::Reg<regs::Qmem16, crate::common::RW> {
200 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xa8usize) as _) }
201 }
202 #[doc = "JPEG quantization tables"]
203 #[inline(always)]
204 pub const fn qmem1_7(self) -> crate::common::Reg<regs::Qmem17, crate::common::RW> {
205 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xacusize) as _) }
206 }
207 #[doc = "JPEG quantization tables"]
208 #[inline(always)]
209 pub const fn qmem1_8(self) -> crate::common::Reg<regs::Qmem18, crate::common::RW> {
210 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xb0usize) as _) }
211 }
212 #[doc = "JPEG quantization tables"]
213 #[inline(always)]
214 pub const fn qmem1_9(self) -> crate::common::Reg<regs::Qmem19, crate::common::RW> {
215 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xb4usize) as _) }
216 }
217 #[doc = "JPEG quantization tables"]
218 #[inline(always)]
219 pub const fn qmem1_10(self) -> crate::common::Reg<regs::Qmem110, crate::common::RW> {
220 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xb8usize) as _) }
221 }
222 #[doc = "JPEG quantization tables"]
223 #[inline(always)]
224 pub const fn qmem1_11(self) -> crate::common::Reg<regs::Qmem111, crate::common::RW> {
225 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xbcusize) as _) }
226 }
227 #[doc = "JPEG quantization tables"]
228 #[inline(always)]
229 pub const fn qmem1_12(self) -> crate::common::Reg<regs::Qmem112, crate::common::RW> {
230 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xc0usize) as _) }
231 }
232 #[doc = "JPEG quantization tables"]
233 #[inline(always)]
234 pub const fn qmem1_13(self) -> crate::common::Reg<regs::Qmem113, crate::common::RW> {
235 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xc4usize) as _) }
236 }
237 #[doc = "JPEG quantization tables"]
238 #[inline(always)]
239 pub const fn qmem1_14(self) -> crate::common::Reg<regs::Qmem114, crate::common::RW> {
240 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xc8usize) as _) }
241 }
242 #[doc = "JPEG quantization tables"]
243 #[inline(always)]
244 pub const fn qmem1_15(self) -> crate::common::Reg<regs::Qmem115, crate::common::RW> {
245 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xccusize) as _) }
246 }
247 #[doc = "JPEG quantization tables"]
248 #[inline(always)]
249 pub const fn qmem2_0(self) -> crate::common::Reg<regs::Qmem20, crate::common::RW> {
250 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xd0usize) as _) }
251 }
252 #[doc = "JPEG quantization tables"]
253 #[inline(always)]
254 pub const fn qmem2_1(self) -> crate::common::Reg<regs::Qmem21, crate::common::RW> {
255 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xd4usize) as _) }
256 }
257 #[doc = "JPEG quantization tables"]
258 #[inline(always)]
259 pub const fn qmem2_2(self) -> crate::common::Reg<regs::Qmem22, crate::common::RW> {
260 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xd8usize) as _) }
261 }
262 #[doc = "JPEG quantization tables"]
263 #[inline(always)]
264 pub const fn qmem2_3(self) -> crate::common::Reg<regs::Qmem23, crate::common::RW> {
265 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xdcusize) as _) }
266 }
267 #[doc = "JPEG quantization tables"]
268 #[inline(always)]
269 pub const fn qmem2_4(self) -> crate::common::Reg<regs::Qmem24, crate::common::RW> {
270 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xe0usize) as _) }
271 }
272 #[doc = "JPEG quantization tables"]
273 #[inline(always)]
274 pub const fn qmem2_5(self) -> crate::common::Reg<regs::Qmem25, crate::common::RW> {
275 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xe4usize) as _) }
276 }
277 #[doc = "JPEG quantization tables"]
278 #[inline(always)]
279 pub const fn qmem2_6(self) -> crate::common::Reg<regs::Qmem26, crate::common::RW> {
280 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xe8usize) as _) }
281 }
282 #[doc = "JPEG quantization tables"]
283 #[inline(always)]
284 pub const fn qmem2_7(self) -> crate::common::Reg<regs::Qmem27, crate::common::RW> {
285 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xecusize) as _) }
286 }
287 #[doc = "JPEG quantization tables"]
288 #[inline(always)]
289 pub const fn qmem2_8(self) -> crate::common::Reg<regs::Qmem28, crate::common::RW> {
290 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xf0usize) as _) }
291 }
292 #[doc = "JPEG quantization tables"]
293 #[inline(always)]
294 pub const fn qmem2_9(self) -> crate::common::Reg<regs::Qmem29, crate::common::RW> {
295 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xf4usize) as _) }
296 }
297 #[doc = "JPEG quantization tables"]
298 #[inline(always)]
299 pub const fn qmem2_10(self) -> crate::common::Reg<regs::Qmem210, crate::common::RW> {
300 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xf8usize) as _) }
301 }
302 #[doc = "JPEG quantization tables"]
303 #[inline(always)]
304 pub const fn qmem2_11(self) -> crate::common::Reg<regs::Qmem211, crate::common::RW> {
305 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0xfcusize) as _) }
306 }
307 #[doc = "JPEG quantization tables"]
308 #[inline(always)]
309 pub const fn qmem2_12(self) -> crate::common::Reg<regs::Qmem212, crate::common::RW> {
310 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0100usize) as _) }
311 }
312 #[doc = "JPEG quantization tables"]
313 #[inline(always)]
314 pub const fn qmem2_13(self) -> crate::common::Reg<regs::Qmem213, crate::common::RW> {
315 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0104usize) as _) }
316 }
317 #[doc = "JPEG quantization tables"]
318 #[inline(always)]
319 pub const fn qmem2_14(self) -> crate::common::Reg<regs::Qmem214, crate::common::RW> {
320 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0108usize) as _) }
321 }
322 #[doc = "JPEG quantization tables"]
323 #[inline(always)]
324 pub const fn qmem2_15(self) -> crate::common::Reg<regs::Qmem215, crate::common::RW> {
325 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x010cusize) as _) }
326 }
327 #[doc = "JPEG quantization tables"]
328 #[inline(always)]
329 pub const fn qmem3_0(self) -> crate::common::Reg<regs::Qmem30, crate::common::RW> {
330 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0110usize) as _) }
331 }
332 #[doc = "JPEG quantization tables"]
333 #[inline(always)]
334 pub const fn qmem3_1(self) -> crate::common::Reg<regs::Qmem31, crate::common::RW> {
335 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0114usize) as _) }
336 }
337 #[doc = "JPEG quantization tables"]
338 #[inline(always)]
339 pub const fn qmem3_2(self) -> crate::common::Reg<regs::Qmem32, crate::common::RW> {
340 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0118usize) as _) }
341 }
342 #[doc = "JPEG quantization tables"]
343 #[inline(always)]
344 pub const fn qmem3_3(self) -> crate::common::Reg<regs::Qmem33, crate::common::RW> {
345 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x011cusize) as _) }
346 }
347 #[doc = "JPEG quantization tables"]
348 #[inline(always)]
349 pub const fn qmem3_4(self) -> crate::common::Reg<regs::Qmem34, crate::common::RW> {
350 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0120usize) as _) }
351 }
352 #[doc = "JPEG quantization tables"]
353 #[inline(always)]
354 pub const fn qmem3_5(self) -> crate::common::Reg<regs::Qmem35, crate::common::RW> {
355 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0124usize) as _) }
356 }
357 #[doc = "JPEG quantization tables"]
358 #[inline(always)]
359 pub const fn qmem3_6(self) -> crate::common::Reg<regs::Qmem36, crate::common::RW> {
360 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0128usize) as _) }
361 }
362 #[doc = "JPEG quantization tables"]
363 #[inline(always)]
364 pub const fn qmem3_7(self) -> crate::common::Reg<regs::Qmem37, crate::common::RW> {
365 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x012cusize) as _) }
366 }
367 #[doc = "JPEG quantization tables"]
368 #[inline(always)]
369 pub const fn qmem3_8(self) -> crate::common::Reg<regs::Qmem38, crate::common::RW> {
370 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0130usize) as _) }
371 }
372 #[doc = "JPEG quantization tables"]
373 #[inline(always)]
374 pub const fn qmem3_9(self) -> crate::common::Reg<regs::Qmem39, crate::common::RW> {
375 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0134usize) as _) }
376 }
377 #[doc = "JPEG quantization tables"]
378 #[inline(always)]
379 pub const fn qmem3_10(self) -> crate::common::Reg<regs::Qmem310, crate::common::RW> {
380 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0138usize) as _) }
381 }
382 #[doc = "JPEG quantization tables"]
383 #[inline(always)]
384 pub const fn qmem3_11(self) -> crate::common::Reg<regs::Qmem311, crate::common::RW> {
385 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x013cusize) as _) }
386 }
387 #[doc = "JPEG quantization tables"]
388 #[inline(always)]
389 pub const fn qmem3_12(self) -> crate::common::Reg<regs::Qmem312, crate::common::RW> {
390 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0140usize) as _) }
391 }
392 #[doc = "JPEG quantization tables"]
393 #[inline(always)]
394 pub const fn qmem3_13(self) -> crate::common::Reg<regs::Qmem313, crate::common::RW> {
395 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0144usize) as _) }
396 }
397 #[doc = "JPEG quantization tables"]
398 #[inline(always)]
399 pub const fn qmem3_14(self) -> crate::common::Reg<regs::Qmem314, crate::common::RW> {
400 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0148usize) as _) }
401 }
402 #[doc = "JPEG quantization tables"]
403 #[inline(always)]
404 pub const fn qmem3_15(self) -> crate::common::Reg<regs::Qmem315, crate::common::RW> {
405 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x014cusize) as _) }
406 }
407 #[doc = "JPEG HuffMin tables"]
408 #[inline(always)]
409 pub const fn huffmin_0(self) -> crate::common::Reg<regs::Huffmin0, crate::common::RW> {
410 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0150usize) as _) }
411 }
412 #[doc = "JPEG HuffMin tables"]
413 #[inline(always)]
414 pub const fn huffmin_1(self) -> crate::common::Reg<regs::Huffmin1, crate::common::RW> {
415 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0154usize) as _) }
416 }
417 #[doc = "JPEG HuffMin tables"]
418 #[inline(always)]
419 pub const fn huffmin_2(self) -> crate::common::Reg<regs::Huffmin2, crate::common::RW> {
420 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0158usize) as _) }
421 }
422 #[doc = "JPEG HuffMin tables"]
423 #[inline(always)]
424 pub const fn huffmin_3(self) -> crate::common::Reg<regs::Huffmin3, crate::common::RW> {
425 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x015cusize) as _) }
426 }
427 #[doc = "JPEG HuffMin tables"]
428 #[inline(always)]
429 pub const fn huffmin_4(self) -> crate::common::Reg<regs::Huffmin4, crate::common::RW> {
430 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0160usize) as _) }
431 }
432 #[doc = "JPEG HuffMin tables"]
433 #[inline(always)]
434 pub const fn huffmin_5(self) -> crate::common::Reg<regs::Huffmin5, crate::common::RW> {
435 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0164usize) as _) }
436 }
437 #[doc = "JPEG HuffMin tables"]
438 #[inline(always)]
439 pub const fn huffmin_6(self) -> crate::common::Reg<regs::Huffmin6, crate::common::RW> {
440 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0168usize) as _) }
441 }
442 #[doc = "JPEG HuffMin tables"]
443 #[inline(always)]
444 pub const fn huffmin_7(self) -> crate::common::Reg<regs::Huffmin7, crate::common::RW> {
445 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x016cusize) as _) }
446 }
447 #[doc = "JPEG HuffMin tables"]
448 #[inline(always)]
449 pub const fn huffmin_8(self) -> crate::common::Reg<regs::Huffmin8, crate::common::RW> {
450 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0170usize) as _) }
451 }
452 #[doc = "JPEG HuffMin tables"]
453 #[inline(always)]
454 pub const fn huffmin_9(self) -> crate::common::Reg<regs::Huffmin9, crate::common::RW> {
455 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0174usize) as _) }
456 }
457 #[doc = "JPEG HuffMin tables"]
458 #[inline(always)]
459 pub const fn huffmin_10(self) -> crate::common::Reg<regs::Huffmin10, crate::common::RW> {
460 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0178usize) as _) }
461 }
462 #[doc = "JPEG HuffMin tables"]
463 #[inline(always)]
464 pub const fn huffmin_11(self) -> crate::common::Reg<regs::Huffmin11, crate::common::RW> {
465 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x017cusize) as _) }
466 }
467 #[doc = "JPEG HuffMin tables"]
468 #[inline(always)]
469 pub const fn huffmin_12(self) -> crate::common::Reg<regs::Huffmin12, crate::common::RW> {
470 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0180usize) as _) }
471 }
472 #[doc = "JPEG HuffMin tables"]
473 #[inline(always)]
474 pub const fn huffmin_13(self) -> crate::common::Reg<regs::Huffmin13, crate::common::RW> {
475 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0184usize) as _) }
476 }
477 #[doc = "JPEG HuffMin tables"]
478 #[inline(always)]
479 pub const fn huffmin_14(self) -> crate::common::Reg<regs::Huffmin14, crate::common::RW> {
480 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0188usize) as _) }
481 }
482 #[doc = "JPEG HuffMin tables"]
483 #[inline(always)]
484 pub const fn huffmin_15(self) -> crate::common::Reg<regs::Huffmin15, crate::common::RW> {
485 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x018cusize) as _) }
486 }
487 #[doc = "JPEG HuffSymb tables"]
488 #[inline(always)]
489 pub const fn huffbase0(self) -> crate::common::Reg<regs::Huffbase0, crate::common::RW> {
490 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0190usize) as _) }
491 }
492 #[doc = "JPEG HuffSymb tables"]
493 #[inline(always)]
494 pub const fn huffbase1(self) -> crate::common::Reg<regs::Huffbase1, crate::common::RW> {
495 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0194usize) as _) }
496 }
497 #[doc = "JPEG HuffSymb tables"]
498 #[inline(always)]
499 pub const fn huffbase2(self) -> crate::common::Reg<regs::Huffbase2, crate::common::RW> {
500 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0198usize) as _) }
501 }
502 #[doc = "JPEG HuffSymb tables"]
503 #[inline(always)]
504 pub const fn huffbase3(self) -> crate::common::Reg<regs::Huffbase3, crate::common::RW> {
505 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x019cusize) as _) }
506 }
507 #[doc = "JPEG HuffSymb tables"]
508 #[inline(always)]
509 pub const fn huffbase4(self) -> crate::common::Reg<regs::Huffbase4, crate::common::RW> {
510 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01a0usize) as _) }
511 }
512 #[doc = "JPEG HuffSymb tables"]
513 #[inline(always)]
514 pub const fn huffbase5(self) -> crate::common::Reg<regs::Huffbase5, crate::common::RW> {
515 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01a4usize) as _) }
516 }
517 #[doc = "JPEG HuffSymb tables"]
518 #[inline(always)]
519 pub const fn huffbase6(self) -> crate::common::Reg<regs::Huffbase6, crate::common::RW> {
520 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01a8usize) as _) }
521 }
522 #[doc = "JPEG HuffSymb tables"]
523 #[inline(always)]
524 pub const fn huffbase7(self) -> crate::common::Reg<regs::Huffbase7, crate::common::RW> {
525 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01acusize) as _) }
526 }
527 #[doc = "JPEG HuffSymb tables"]
528 #[inline(always)]
529 pub const fn huffbase8(self) -> crate::common::Reg<regs::Huffbase8, crate::common::RW> {
530 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01b0usize) as _) }
531 }
532 #[doc = "JPEG HuffSymb tables"]
533 #[inline(always)]
534 pub const fn huffbase9(self) -> crate::common::Reg<regs::Huffbase9, crate::common::RW> {
535 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01b4usize) as _) }
536 }
537 #[doc = "JPEG HuffSymb tables"]
538 #[inline(always)]
539 pub const fn huffbase10(self) -> crate::common::Reg<regs::Huffbase10, crate::common::RW> {
540 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01b8usize) as _) }
541 }
542 #[doc = "JPEG HuffSymb tables"]
543 #[inline(always)]
544 pub const fn huffbase11(self) -> crate::common::Reg<regs::Huffbase11, crate::common::RW> {
545 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01bcusize) as _) }
546 }
547 #[doc = "JPEG HuffSymb tables"]
548 #[inline(always)]
549 pub const fn huffbase12(self) -> crate::common::Reg<regs::Huffbase12, crate::common::RW> {
550 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01c0usize) as _) }
551 }
552 #[doc = "JPEG HuffSymb tables"]
553 #[inline(always)]
554 pub const fn huffbase13(self) -> crate::common::Reg<regs::Huffbase13, crate::common::RW> {
555 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01c4usize) as _) }
556 }
557 #[doc = "JPEG HuffSymb tables"]
558 #[inline(always)]
559 pub const fn huffbase14(self) -> crate::common::Reg<regs::Huffbase14, crate::common::RW> {
560 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01c8usize) as _) }
561 }
562 #[doc = "JPEG HuffSymb tables"]
563 #[inline(always)]
564 pub const fn huffbase15(self) -> crate::common::Reg<regs::Huffbase15, crate::common::RW> {
565 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01ccusize) as _) }
566 }
567 #[doc = "JPEG HuffSymb tables"]
568 #[inline(always)]
569 pub const fn huffbase16(self) -> crate::common::Reg<regs::Huffbase16, crate::common::RW> {
570 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01d0usize) as _) }
571 }
572 #[doc = "JPEG HuffSymb tables"]
573 #[inline(always)]
574 pub const fn huffbase17(self) -> crate::common::Reg<regs::Huffbase17, crate::common::RW> {
575 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01d4usize) as _) }
576 }
577 #[doc = "JPEG HuffSymb tables"]
578 #[inline(always)]
579 pub const fn huffbase18(self) -> crate::common::Reg<regs::Huffbase18, crate::common::RW> {
580 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01d8usize) as _) }
581 }
582 #[doc = "JPEG HuffSymb tables"]
583 #[inline(always)]
584 pub const fn huffbase19(self) -> crate::common::Reg<regs::Huffbase19, crate::common::RW> {
585 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01dcusize) as _) }
586 }
587 #[doc = "JPEG HuffSymb tables"]
588 #[inline(always)]
589 pub const fn huffbase20(self) -> crate::common::Reg<regs::Huffbase20, crate::common::RW> {
590 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01e0usize) as _) }
591 }
592 #[doc = "JPEG HuffSymb tables"]
593 #[inline(always)]
594 pub const fn huffbase21(self) -> crate::common::Reg<regs::Huffbase21, crate::common::RW> {
595 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01e4usize) as _) }
596 }
597 #[doc = "JPEG HuffSymb tables"]
598 #[inline(always)]
599 pub const fn huffbase22(self) -> crate::common::Reg<regs::Huffbase22, crate::common::RW> {
600 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01e8usize) as _) }
601 }
602 #[doc = "JPEG HuffSymb tables"]
603 #[inline(always)]
604 pub const fn huffbase23(self) -> crate::common::Reg<regs::Huffbase23, crate::common::RW> {
605 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01ecusize) as _) }
606 }
607 #[doc = "JPEG HuffSymb tables"]
608 #[inline(always)]
609 pub const fn huffbase24(self) -> crate::common::Reg<regs::Huffbase24, crate::common::RW> {
610 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01f0usize) as _) }
611 }
612 #[doc = "JPEG HuffSymb tables"]
613 #[inline(always)]
614 pub const fn huffbase25(self) -> crate::common::Reg<regs::Huffbase25, crate::common::RW> {
615 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01f4usize) as _) }
616 }
617 #[doc = "JPEG HuffSymb tables"]
618 #[inline(always)]
619 pub const fn huffbase26(self) -> crate::common::Reg<regs::Huffbase26, crate::common::RW> {
620 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01f8usize) as _) }
621 }
622 #[doc = "JPEG HuffSymb tables"]
623 #[inline(always)]
624 pub const fn huffbase27(self) -> crate::common::Reg<regs::Huffbase27, crate::common::RW> {
625 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x01fcusize) as _) }
626 }
627 #[doc = "JPEG HuffSymb tables"]
628 #[inline(always)]
629 pub const fn huffbase28(self) -> crate::common::Reg<regs::Huffbase28, crate::common::RW> {
630 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0200usize) as _) }
631 }
632 #[doc = "JPEG HuffSymb tables"]
633 #[inline(always)]
634 pub const fn huffbase29(self) -> crate::common::Reg<regs::Huffbase29, crate::common::RW> {
635 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0204usize) as _) }
636 }
637 #[doc = "JPEG HuffSymb tables"]
638 #[inline(always)]
639 pub const fn huffbase30(self) -> crate::common::Reg<regs::Huffbase30, crate::common::RW> {
640 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0208usize) as _) }
641 }
642 #[doc = "JPEG HuffSymb tables"]
643 #[inline(always)]
644 pub const fn huffbase31(self) -> crate::common::Reg<regs::Huffbase31, crate::common::RW> {
645 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x020cusize) as _) }
646 }
647 #[doc = "JPEG HUFFSYMB tables"]
648 #[inline(always)]
649 pub const fn huffsymb0(self) -> crate::common::Reg<regs::Huffsymb0, crate::common::RW> {
650 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0210usize) as _) }
651 }
652 #[doc = "JPEG HUFFSYMB tables"]
653 #[inline(always)]
654 pub const fn huffsymb1(self) -> crate::common::Reg<regs::Huffsymb1, crate::common::RW> {
655 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0214usize) as _) }
656 }
657 #[doc = "JPEG HUFFSYMB tables"]
658 #[inline(always)]
659 pub const fn huffsymb2(self) -> crate::common::Reg<regs::Huffsymb2, crate::common::RW> {
660 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0218usize) as _) }
661 }
662 #[doc = "JPEG HUFFSYMB tables"]
663 #[inline(always)]
664 pub const fn huffsymb3(self) -> crate::common::Reg<regs::Huffsymb3, crate::common::RW> {
665 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x021cusize) as _) }
666 }
667 #[doc = "JPEG HUFFSYMB tables"]
668 #[inline(always)]
669 pub const fn huffsymb4(self) -> crate::common::Reg<regs::Huffsymb4, crate::common::RW> {
670 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0220usize) as _) }
671 }
672 #[doc = "JPEG HUFFSYMB tables"]
673 #[inline(always)]
674 pub const fn huffsymb5(self) -> crate::common::Reg<regs::Huffsymb5, crate::common::RW> {
675 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0224usize) as _) }
676 }
677 #[doc = "JPEG HUFFSYMB tables"]
678 #[inline(always)]
679 pub const fn huffsymb6(self) -> crate::common::Reg<regs::Huffsymb6, crate::common::RW> {
680 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0228usize) as _) }
681 }
682 #[doc = "JPEG HUFFSYMB tables"]
683 #[inline(always)]
684 pub const fn huffsymb7(self) -> crate::common::Reg<regs::Huffsymb7, crate::common::RW> {
685 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x022cusize) as _) }
686 }
687 #[doc = "JPEG HUFFSYMB tables"]
688 #[inline(always)]
689 pub const fn huffsymb8(self) -> crate::common::Reg<regs::Huffsymb8, crate::common::RW> {
690 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0230usize) as _) }
691 }
692 #[doc = "JPEG HUFFSYMB tables"]
693 #[inline(always)]
694 pub const fn huffsymb9(self) -> crate::common::Reg<regs::Huffsymb9, crate::common::RW> {
695 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0234usize) as _) }
696 }
697 #[doc = "JPEG HUFFSYMB tables"]
698 #[inline(always)]
699 pub const fn huffsymb10(self) -> crate::common::Reg<regs::Huffsymb10, crate::common::RW> {
700 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0238usize) as _) }
701 }
702 #[doc = "JPEG HUFFSYMB tables"]
703 #[inline(always)]
704 pub const fn huffsymb11(self) -> crate::common::Reg<regs::Huffsymb11, crate::common::RW> {
705 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x023cusize) as _) }
706 }
707 #[doc = "JPEG HUFFSYMB tables"]
708 #[inline(always)]
709 pub const fn huffsymb12(self) -> crate::common::Reg<regs::Huffsymb12, crate::common::RW> {
710 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0240usize) as _) }
711 }
712 #[doc = "JPEG HUFFSYMB tables"]
713 #[inline(always)]
714 pub const fn huffsymb13(self) -> crate::common::Reg<regs::Huffsymb13, crate::common::RW> {
715 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0244usize) as _) }
716 }
717 #[doc = "JPEG HUFFSYMB tables"]
718 #[inline(always)]
719 pub const fn huffsymb14(self) -> crate::common::Reg<regs::Huffsymb14, crate::common::RW> {
720 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0248usize) as _) }
721 }
722 #[doc = "JPEG HUFFSYMB tables"]
723 #[inline(always)]
724 pub const fn huffsymb15(self) -> crate::common::Reg<regs::Huffsymb15, crate::common::RW> {
725 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x024cusize) as _) }
726 }
727 #[doc = "JPEG HUFFSYMB tables"]
728 #[inline(always)]
729 pub const fn huffsymb16(self) -> crate::common::Reg<regs::Huffsymb16, crate::common::RW> {
730 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0250usize) as _) }
731 }
732 #[doc = "JPEG HUFFSYMB tables"]
733 #[inline(always)]
734 pub const fn huffsymb17(self) -> crate::common::Reg<regs::Huffsymb17, crate::common::RW> {
735 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0254usize) as _) }
736 }
737 #[doc = "JPEG HUFFSYMB tables"]
738 #[inline(always)]
739 pub const fn huffsymb18(self) -> crate::common::Reg<regs::Huffsymb18, crate::common::RW> {
740 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0258usize) as _) }
741 }
742 #[doc = "JPEG HUFFSYMB tables"]
743 #[inline(always)]
744 pub const fn huffsymb19(self) -> crate::common::Reg<regs::Huffsymb19, crate::common::RW> {
745 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x025cusize) as _) }
746 }
747 #[doc = "JPEG HUFFSYMB tables"]
748 #[inline(always)]
749 pub const fn huffsymb20(self) -> crate::common::Reg<regs::Huffsymb20, crate::common::RW> {
750 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0260usize) as _) }
751 }
752 #[doc = "JPEG HUFFSYMB tables"]
753 #[inline(always)]
754 pub const fn huffsymb21(self) -> crate::common::Reg<regs::Huffsymb21, crate::common::RW> {
755 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0264usize) as _) }
756 }
757 #[doc = "JPEG HUFFSYMB tables"]
758 #[inline(always)]
759 pub const fn huffsymb22(self) -> crate::common::Reg<regs::Huffsymb22, crate::common::RW> {
760 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0268usize) as _) }
761 }
762 #[doc = "JPEG HUFFSYMB tables"]
763 #[inline(always)]
764 pub const fn huffsymb23(self) -> crate::common::Reg<regs::Huffsymb23, crate::common::RW> {
765 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x026cusize) as _) }
766 }
767 #[doc = "JPEG HUFFSYMB tables"]
768 #[inline(always)]
769 pub const fn huffsymb24(self) -> crate::common::Reg<regs::Huffsymb24, crate::common::RW> {
770 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0270usize) as _) }
771 }
772 #[doc = "JPEG HUFFSYMB tables"]
773 #[inline(always)]
774 pub const fn huffsymb25(self) -> crate::common::Reg<regs::Huffsymb25, crate::common::RW> {
775 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0274usize) as _) }
776 }
777 #[doc = "JPEG HUFFSYMB tables"]
778 #[inline(always)]
779 pub const fn huffsymb26(self) -> crate::common::Reg<regs::Huffsymb26, crate::common::RW> {
780 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0278usize) as _) }
781 }
782 #[doc = "JPEG HUFFSYMB tables"]
783 #[inline(always)]
784 pub const fn huffsymb27(self) -> crate::common::Reg<regs::Huffsymb27, crate::common::RW> {
785 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x027cusize) as _) }
786 }
787 #[doc = "JPEG HUFFSYMB tables"]
788 #[inline(always)]
789 pub const fn huffsymb28(self) -> crate::common::Reg<regs::Huffsymb28, crate::common::RW> {
790 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0280usize) as _) }
791 }
792 #[doc = "JPEG HUFFSYMB tables"]
793 #[inline(always)]
794 pub const fn huffsymb29(self) -> crate::common::Reg<regs::Huffsymb29, crate::common::RW> {
795 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0284usize) as _) }
796 }
797 #[doc = "JPEG HUFFSYMB tables"]
798 #[inline(always)]
799 pub const fn huffsymb30(self) -> crate::common::Reg<regs::Huffsymb30, crate::common::RW> {
800 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0288usize) as _) }
801 }
802 #[doc = "JPEG HUFFSYMB tables"]
803 #[inline(always)]
804 pub const fn huffsymb31(self) -> crate::common::Reg<regs::Huffsymb31, crate::common::RW> {
805 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x028cusize) as _) }
806 }
807 #[doc = "JPEG HUFFSYMB tables"]
808 #[inline(always)]
809 pub const fn huffsymb32(self) -> crate::common::Reg<regs::Huffsymb32, crate::common::RW> {
810 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0290usize) as _) }
811 }
812 #[doc = "JPEG HUFFSYMB tables"]
813 #[inline(always)]
814 pub const fn huffsymb33(self) -> crate::common::Reg<regs::Huffsymb33, crate::common::RW> {
815 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0294usize) as _) }
816 }
817 #[doc = "JPEG HUFFSYMB tables"]
818 #[inline(always)]
819 pub const fn huffsymb34(self) -> crate::common::Reg<regs::Huffsymb34, crate::common::RW> {
820 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0298usize) as _) }
821 }
822 #[doc = "JPEG HUFFSYMB tables"]
823 #[inline(always)]
824 pub const fn huffsymb35(self) -> crate::common::Reg<regs::Huffsymb35, crate::common::RW> {
825 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x029cusize) as _) }
826 }
827 #[doc = "JPEG HUFFSYMB tables"]
828 #[inline(always)]
829 pub const fn huffsymb36(self) -> crate::common::Reg<regs::Huffsymb36, crate::common::RW> {
830 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02a0usize) as _) }
831 }
832 #[doc = "JPEG HUFFSYMB tables"]
833 #[inline(always)]
834 pub const fn huffsymb37(self) -> crate::common::Reg<regs::Huffsymb37, crate::common::RW> {
835 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02a4usize) as _) }
836 }
837 #[doc = "JPEG HUFFSYMB tables"]
838 #[inline(always)]
839 pub const fn huffsymb38(self) -> crate::common::Reg<regs::Huffsymb38, crate::common::RW> {
840 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02a8usize) as _) }
841 }
842 #[doc = "JPEG HUFFSYMB tables"]
843 #[inline(always)]
844 pub const fn huffsymb39(self) -> crate::common::Reg<regs::Huffsymb39, crate::common::RW> {
845 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02acusize) as _) }
846 }
847 #[doc = "JPEG HUFFSYMB tables"]
848 #[inline(always)]
849 pub const fn huffsymb40(self) -> crate::common::Reg<regs::Huffsymb40, crate::common::RW> {
850 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02b0usize) as _) }
851 }
852 #[doc = "JPEG HUFFSYMB tables"]
853 #[inline(always)]
854 pub const fn huffsymb41(self) -> crate::common::Reg<regs::Huffsymb41, crate::common::RW> {
855 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02b4usize) as _) }
856 }
857 #[doc = "JPEG HUFFSYMB tables"]
858 #[inline(always)]
859 pub const fn huffsymb42(self) -> crate::common::Reg<regs::Huffsymb42, crate::common::RW> {
860 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02b8usize) as _) }
861 }
862 #[doc = "JPEG HUFFSYMB tables"]
863 #[inline(always)]
864 pub const fn huffsymb43(self) -> crate::common::Reg<regs::Huffsymb43, crate::common::RW> {
865 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02bcusize) as _) }
866 }
867 #[doc = "JPEG HUFFSYMB tables"]
868 #[inline(always)]
869 pub const fn huffsymb44(self) -> crate::common::Reg<regs::Huffsymb44, crate::common::RW> {
870 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02c0usize) as _) }
871 }
872 #[doc = "JPEG HUFFSYMB tables"]
873 #[inline(always)]
874 pub const fn huffsymb45(self) -> crate::common::Reg<regs::Huffsymb45, crate::common::RW> {
875 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02c4usize) as _) }
876 }
877 #[doc = "JPEG HUFFSYMB tables"]
878 #[inline(always)]
879 pub const fn huffsymb46(self) -> crate::common::Reg<regs::Huffsymb46, crate::common::RW> {
880 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02c8usize) as _) }
881 }
882 #[doc = "JPEG HUFFSYMB tables"]
883 #[inline(always)]
884 pub const fn huffsymb47(self) -> crate::common::Reg<regs::Huffsymb47, crate::common::RW> {
885 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02ccusize) as _) }
886 }
887 #[doc = "JPEG HUFFSYMB tables"]
888 #[inline(always)]
889 pub const fn huffsymb48(self) -> crate::common::Reg<regs::Huffsymb48, crate::common::RW> {
890 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02d0usize) as _) }
891 }
892 #[doc = "JPEG HUFFSYMB tables"]
893 #[inline(always)]
894 pub const fn huffsymb49(self) -> crate::common::Reg<regs::Huffsymb49, crate::common::RW> {
895 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02d4usize) as _) }
896 }
897 #[doc = "JPEG HUFFSYMB tables"]
898 #[inline(always)]
899 pub const fn huffsymb50(self) -> crate::common::Reg<regs::Huffsymb50, crate::common::RW> {
900 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02d8usize) as _) }
901 }
902 #[doc = "JPEG HUFFSYMB tables"]
903 #[inline(always)]
904 pub const fn huffsymb51(self) -> crate::common::Reg<regs::Huffsymb51, crate::common::RW> {
905 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02dcusize) as _) }
906 }
907 #[doc = "JPEG HUFFSYMB tables"]
908 #[inline(always)]
909 pub const fn huffsymb52(self) -> crate::common::Reg<regs::Huffsymb52, crate::common::RW> {
910 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02e0usize) as _) }
911 }
912 #[doc = "JPEG HUFFSYMB tables"]
913 #[inline(always)]
914 pub const fn huffsymb53(self) -> crate::common::Reg<regs::Huffsymb53, crate::common::RW> {
915 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02e4usize) as _) }
916 }
917 #[doc = "JPEG HUFFSYMB tables"]
918 #[inline(always)]
919 pub const fn huffsymb54(self) -> crate::common::Reg<regs::Huffsymb54, crate::common::RW> {
920 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02e8usize) as _) }
921 }
922 #[doc = "JPEG HUFFSYMB tables"]
923 #[inline(always)]
924 pub const fn huffsymb55(self) -> crate::common::Reg<regs::Huffsymb55, crate::common::RW> {
925 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02ecusize) as _) }
926 }
927 #[doc = "JPEG HUFFSYMB tables"]
928 #[inline(always)]
929 pub const fn huffsymb56(self) -> crate::common::Reg<regs::Huffsymb56, crate::common::RW> {
930 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02f0usize) as _) }
931 }
932 #[doc = "JPEG HUFFSYMB tables"]
933 #[inline(always)]
934 pub const fn huffsymb57(self) -> crate::common::Reg<regs::Huffsymb57, crate::common::RW> {
935 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02f4usize) as _) }
936 }
937 #[doc = "JPEG HUFFSYMB tables"]
938 #[inline(always)]
939 pub const fn huffsymb58(self) -> crate::common::Reg<regs::Huffsymb58, crate::common::RW> {
940 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02f8usize) as _) }
941 }
942 #[doc = "JPEG HUFFSYMB tables"]
943 #[inline(always)]
944 pub const fn huffsymb59(self) -> crate::common::Reg<regs::Huffsymb59, crate::common::RW> {
945 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x02fcusize) as _) }
946 }
947 #[doc = "JPEG HUFFSYMB tables"]
948 #[inline(always)]
949 pub const fn huffsymb60(self) -> crate::common::Reg<regs::Huffsymb60, crate::common::RW> {
950 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0300usize) as _) }
951 }
952 #[doc = "JPEG HUFFSYMB tables"]
953 #[inline(always)]
954 pub const fn huffsymb61(self) -> crate::common::Reg<regs::Huffsymb61, crate::common::RW> {
955 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0304usize) as _) }
956 }
957 #[doc = "JPEG HUFFSYMB tables"]
958 #[inline(always)]
959 pub const fn huffsymb62(self) -> crate::common::Reg<regs::Huffsymb62, crate::common::RW> {
960 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0308usize) as _) }
961 }
962 #[doc = "JPEG HUFFSYMB tables"]
963 #[inline(always)]
964 pub const fn huffsymb63(self) -> crate::common::Reg<regs::Huffsymb63, crate::common::RW> {
965 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x030cusize) as _) }
966 }
967 #[doc = "JPEG HUFFSYMB tables"]
968 #[inline(always)]
969 pub const fn huffsymb64(self) -> crate::common::Reg<regs::Huffsymb64, crate::common::RW> {
970 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0310usize) as _) }
971 }
972 #[doc = "JPEG HUFFSYMB tables"]
973 #[inline(always)]
974 pub const fn huffsymb65(self) -> crate::common::Reg<regs::Huffsymb65, crate::common::RW> {
975 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0314usize) as _) }
976 }
977 #[doc = "JPEG HUFFSYMB tables"]
978 #[inline(always)]
979 pub const fn huffsymb66(self) -> crate::common::Reg<regs::Huffsymb66, crate::common::RW> {
980 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0318usize) as _) }
981 }
982 #[doc = "JPEG HUFFSYMB tables"]
983 #[inline(always)]
984 pub const fn huffsymb67(self) -> crate::common::Reg<regs::Huffsymb67, crate::common::RW> {
985 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x031cusize) as _) }
986 }
987 #[doc = "JPEG HUFFSYMB tables"]
988 #[inline(always)]
989 pub const fn huffsymb68(self) -> crate::common::Reg<regs::Huffsymb68, crate::common::RW> {
990 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0320usize) as _) }
991 }
992 #[doc = "JPEG HUFFSYMB tables"]
993 #[inline(always)]
994 pub const fn huffsymb69(self) -> crate::common::Reg<regs::Huffsymb69, crate::common::RW> {
995 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0324usize) as _) }
996 }
997 #[doc = "JPEG HUFFSYMB tables"]
998 #[inline(always)]
999 pub const fn huffsymb70(self) -> crate::common::Reg<regs::Huffsymb70, crate::common::RW> {
1000 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0328usize) as _) }
1001 }
1002 #[doc = "JPEG HUFFSYMB tables"]
1003 #[inline(always)]
1004 pub const fn huffsymb71(self) -> crate::common::Reg<regs::Huffsymb71, crate::common::RW> {
1005 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x032cusize) as _) }
1006 }
1007 #[doc = "JPEG HUFFSYMB tables"]
1008 #[inline(always)]
1009 pub const fn huffsymb72(self) -> crate::common::Reg<regs::Huffsymb72, crate::common::RW> {
1010 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0330usize) as _) }
1011 }
1012 #[doc = "JPEG HUFFSYMB tables"]
1013 #[inline(always)]
1014 pub const fn huffsymb73(self) -> crate::common::Reg<regs::Huffsymb73, crate::common::RW> {
1015 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0334usize) as _) }
1016 }
1017 #[doc = "JPEG HUFFSYMB tables"]
1018 #[inline(always)]
1019 pub const fn huffsymb74(self) -> crate::common::Reg<regs::Huffsymb74, crate::common::RW> {
1020 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0338usize) as _) }
1021 }
1022 #[doc = "JPEG HUFFSYMB tables"]
1023 #[inline(always)]
1024 pub const fn huffsymb75(self) -> crate::common::Reg<regs::Huffsymb75, crate::common::RW> {
1025 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x033cusize) as _) }
1026 }
1027 #[doc = "JPEG HUFFSYMB tables"]
1028 #[inline(always)]
1029 pub const fn huffsymb76(self) -> crate::common::Reg<regs::Huffsymb76, crate::common::RW> {
1030 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0340usize) as _) }
1031 }
1032 #[doc = "JPEG HUFFSYMB tables"]
1033 #[inline(always)]
1034 pub const fn huffsymb77(self) -> crate::common::Reg<regs::Huffsymb77, crate::common::RW> {
1035 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0344usize) as _) }
1036 }
1037 #[doc = "JPEG HUFFSYMB tables"]
1038 #[inline(always)]
1039 pub const fn huffsymb78(self) -> crate::common::Reg<regs::Huffsymb78, crate::common::RW> {
1040 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0348usize) as _) }
1041 }
1042 #[doc = "JPEG HUFFSYMB tables"]
1043 #[inline(always)]
1044 pub const fn huffsymb79(self) -> crate::common::Reg<regs::Huffsymb79, crate::common::RW> {
1045 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x034cusize) as _) }
1046 }
1047 #[doc = "JPEG HUFFSYMB tables"]
1048 #[inline(always)]
1049 pub const fn huffsymb80(self) -> crate::common::Reg<regs::Huffsymb80, crate::common::RW> {
1050 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0350usize) as _) }
1051 }
1052 #[doc = "JPEG HUFFSYMB tables"]
1053 #[inline(always)]
1054 pub const fn huffsymb81(self) -> crate::common::Reg<regs::Huffsymb81, crate::common::RW> {
1055 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0354usize) as _) }
1056 }
1057 #[doc = "JPEG HUFFSYMB tables"]
1058 #[inline(always)]
1059 pub const fn huffsymb82(self) -> crate::common::Reg<regs::Huffsymb82, crate::common::RW> {
1060 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0358usize) as _) }
1061 }
1062 #[doc = "JPEG HUFFSYMB tables"]
1063 #[inline(always)]
1064 pub const fn huffsymb83(self) -> crate::common::Reg<regs::Huffsymb83, crate::common::RW> {
1065 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x035cusize) as _) }
1066 }
1067 #[doc = "JPEG DHTMem tables"]
1068 #[inline(always)]
1069 pub const fn dhtmem0(self) -> crate::common::Reg<regs::Dhtmem0, crate::common::RW> {
1070 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0360usize) as _) }
1071 }
1072 #[doc = "JPEG DHTMem tables"]
1073 #[inline(always)]
1074 pub const fn dhtmem2(self) -> crate::common::Reg<regs::Dhtmem2, crate::common::RW> {
1075 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0364usize) as _) }
1076 }
1077 #[doc = "JPEG DHTMem tables"]
1078 #[inline(always)]
1079 pub const fn dhtmem3(self) -> crate::common::Reg<regs::Dhtmem3, crate::common::RW> {
1080 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0368usize) as _) }
1081 }
1082 #[doc = "JPEG DHTMem tables"]
1083 #[inline(always)]
1084 pub const fn dhtmem4(self) -> crate::common::Reg<regs::Dhtmem4, crate::common::RW> {
1085 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x036cusize) as _) }
1086 }
1087 #[doc = "JPEG DHTMem tables"]
1088 #[inline(always)]
1089 pub const fn dhtmem5(self) -> crate::common::Reg<regs::Dhtmem5, crate::common::RW> {
1090 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0370usize) as _) }
1091 }
1092 #[doc = "JPEG DHTMem tables"]
1093 #[inline(always)]
1094 pub const fn dhtmem6(self) -> crate::common::Reg<regs::Dhtmem6, crate::common::RW> {
1095 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0374usize) as _) }
1096 }
1097 #[doc = "JPEG DHTMem tables"]
1098 #[inline(always)]
1099 pub const fn dhtmem7(self) -> crate::common::Reg<regs::Dhtmem7, crate::common::RW> {
1100 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0378usize) as _) }
1101 }
1102 #[doc = "JPEG DHTMem tables"]
1103 #[inline(always)]
1104 pub const fn dhtmem8(self) -> crate::common::Reg<regs::Dhtmem8, crate::common::RW> {
1105 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x037cusize) as _) }
1106 }
1107 #[doc = "JPEG DHTMem tables"]
1108 #[inline(always)]
1109 pub const fn dhtmem9(self) -> crate::common::Reg<regs::Dhtmem9, crate::common::RW> {
1110 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0380usize) as _) }
1111 }
1112 #[doc = "JPEG DHTMem tables"]
1113 #[inline(always)]
1114 pub const fn dhtmem10(self) -> crate::common::Reg<regs::Dhtmem10, crate::common::RW> {
1115 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0384usize) as _) }
1116 }
1117 #[doc = "JPEG DHTMem tables"]
1118 #[inline(always)]
1119 pub const fn dhtmem11(self) -> crate::common::Reg<regs::Dhtmem11, crate::common::RW> {
1120 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0388usize) as _) }
1121 }
1122 #[doc = "JPEG DHTMem tables"]
1123 #[inline(always)]
1124 pub const fn dhtmem12(self) -> crate::common::Reg<regs::Dhtmem12, crate::common::RW> {
1125 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x038cusize) as _) }
1126 }
1127 #[doc = "JPEG DHTMem tables"]
1128 #[inline(always)]
1129 pub const fn dhtmem13(self) -> crate::common::Reg<regs::Dhtmem13, crate::common::RW> {
1130 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0390usize) as _) }
1131 }
1132 #[doc = "JPEG DHTMem tables"]
1133 #[inline(always)]
1134 pub const fn dhtmem14(self) -> crate::common::Reg<regs::Dhtmem14, crate::common::RW> {
1135 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0394usize) as _) }
1136 }
1137 #[doc = "JPEG DHTMem tables"]
1138 #[inline(always)]
1139 pub const fn dhtmem15(self) -> crate::common::Reg<regs::Dhtmem15, crate::common::RW> {
1140 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0398usize) as _) }
1141 }
1142 #[doc = "JPEG DHTMem tables"]
1143 #[inline(always)]
1144 pub const fn dhtmem16(self) -> crate::common::Reg<regs::Dhtmem16, crate::common::RW> {
1145 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x039cusize) as _) }
1146 }
1147 #[doc = "JPEG DHTMem tables"]
1148 #[inline(always)]
1149 pub const fn dhtmem17(self) -> crate::common::Reg<regs::Dhtmem17, crate::common::RW> {
1150 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03a0usize) as _) }
1151 }
1152 #[doc = "JPEG DHTMem tables"]
1153 #[inline(always)]
1154 pub const fn dhtmem18(self) -> crate::common::Reg<regs::Dhtmem18, crate::common::RW> {
1155 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03a4usize) as _) }
1156 }
1157 #[doc = "JPEG DHTMem tables"]
1158 #[inline(always)]
1159 pub const fn dhtmem19(self) -> crate::common::Reg<regs::Dhtmem19, crate::common::RW> {
1160 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03a8usize) as _) }
1161 }
1162 #[doc = "JPEG DHTMem tables"]
1163 #[inline(always)]
1164 pub const fn dhtmem20(self) -> crate::common::Reg<regs::Dhtmem20, crate::common::RW> {
1165 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03acusize) as _) }
1166 }
1167 #[doc = "JPEG DHTMem tables"]
1168 #[inline(always)]
1169 pub const fn dhtmem21(self) -> crate::common::Reg<regs::Dhtmem21, crate::common::RW> {
1170 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03b0usize) as _) }
1171 }
1172 #[doc = "JPEG DHTMem tables"]
1173 #[inline(always)]
1174 pub const fn dhtmem22(self) -> crate::common::Reg<regs::Dhtmem22, crate::common::RW> {
1175 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03b4usize) as _) }
1176 }
1177 #[doc = "JPEG DHTMem tables"]
1178 #[inline(always)]
1179 pub const fn dhtmem23(self) -> crate::common::Reg<regs::Dhtmem23, crate::common::RW> {
1180 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03b8usize) as _) }
1181 }
1182 #[doc = "JPEG DHTMem tables"]
1183 #[inline(always)]
1184 pub const fn dhtmem24(self) -> crate::common::Reg<regs::Dhtmem24, crate::common::RW> {
1185 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03bcusize) as _) }
1186 }
1187 #[doc = "JPEG DHTMem tables"]
1188 #[inline(always)]
1189 pub const fn dhtmem25(self) -> crate::common::Reg<regs::Dhtmem25, crate::common::RW> {
1190 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03c0usize) as _) }
1191 }
1192 #[doc = "JPEG DHTMem tables"]
1193 #[inline(always)]
1194 pub const fn dhtmem26(self) -> crate::common::Reg<regs::Dhtmem26, crate::common::RW> {
1195 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03c4usize) as _) }
1196 }
1197 #[doc = "JPEG DHTMem tables"]
1198 #[inline(always)]
1199 pub const fn dhtmem27(self) -> crate::common::Reg<regs::Dhtmem27, crate::common::RW> {
1200 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03c8usize) as _) }
1201 }
1202 #[doc = "JPEG DHTMem tables"]
1203 #[inline(always)]
1204 pub const fn dhtmem28(self) -> crate::common::Reg<regs::Dhtmem28, crate::common::RW> {
1205 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03ccusize) as _) }
1206 }
1207 #[doc = "JPEG DHTMem tables"]
1208 #[inline(always)]
1209 pub const fn dhtmem29(self) -> crate::common::Reg<regs::Dhtmem29, crate::common::RW> {
1210 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03d0usize) as _) }
1211 }
1212 #[doc = "JPEG DHTMem tables"]
1213 #[inline(always)]
1214 pub const fn dhtmem30(self) -> crate::common::Reg<regs::Dhtmem30, crate::common::RW> {
1215 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03d4usize) as _) }
1216 }
1217 #[doc = "JPEG DHTMem tables"]
1218 #[inline(always)]
1219 pub const fn dhtmem31(self) -> crate::common::Reg<regs::Dhtmem31, crate::common::RW> {
1220 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03d8usize) as _) }
1221 }
1222 #[doc = "JPEG DHTMem tables"]
1223 #[inline(always)]
1224 pub const fn dhtmem32(self) -> crate::common::Reg<regs::Dhtmem32, crate::common::RW> {
1225 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03dcusize) as _) }
1226 }
1227 #[doc = "JPEG DHTMem tables"]
1228 #[inline(always)]
1229 pub const fn dhtmem33(self) -> crate::common::Reg<regs::Dhtmem33, crate::common::RW> {
1230 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03e0usize) as _) }
1231 }
1232 #[doc = "JPEG DHTMem tables"]
1233 #[inline(always)]
1234 pub const fn dhtmem34(self) -> crate::common::Reg<regs::Dhtmem34, crate::common::RW> {
1235 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03e4usize) as _) }
1236 }
1237 #[doc = "JPEG DHTMem tables"]
1238 #[inline(always)]
1239 pub const fn dhtmem35(self) -> crate::common::Reg<regs::Dhtmem35, crate::common::RW> {
1240 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03e8usize) as _) }
1241 }
1242 #[doc = "JPEG DHTMem tables"]
1243 #[inline(always)]
1244 pub const fn dhtmem36(self) -> crate::common::Reg<regs::Dhtmem36, crate::common::RW> {
1245 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03ecusize) as _) }
1246 }
1247 #[doc = "JPEG DHTMem tables"]
1248 #[inline(always)]
1249 pub const fn dhtmem37(self) -> crate::common::Reg<regs::Dhtmem37, crate::common::RW> {
1250 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03f0usize) as _) }
1251 }
1252 #[doc = "JPEG DHTMem tables"]
1253 #[inline(always)]
1254 pub const fn dhtmem38(self) -> crate::common::Reg<regs::Dhtmem38, crate::common::RW> {
1255 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03f4usize) as _) }
1256 }
1257 #[doc = "JPEG DHTMem tables"]
1258 #[inline(always)]
1259 pub const fn dhtmem39(self) -> crate::common::Reg<regs::Dhtmem39, crate::common::RW> {
1260 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03f8usize) as _) }
1261 }
1262 #[doc = "JPEG DHTMem tables"]
1263 #[inline(always)]
1264 pub const fn dhtmem40(self) -> crate::common::Reg<regs::Dhtmem40, crate::common::RW> {
1265 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x03fcusize) as _) }
1266 }
1267 #[doc = "JPEG DHTMem tables"]
1268 #[inline(always)]
1269 pub const fn dhtmem41(self) -> crate::common::Reg<regs::Dhtmem41, crate::common::RW> {
1270 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0400usize) as _) }
1271 }
1272 #[doc = "JPEG DHTMem tables"]
1273 #[inline(always)]
1274 pub const fn dhtmem42(self) -> crate::common::Reg<regs::Dhtmem42, crate::common::RW> {
1275 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0404usize) as _) }
1276 }
1277 #[doc = "JPEG DHTMem tables"]
1278 #[inline(always)]
1279 pub const fn dhtmem43(self) -> crate::common::Reg<regs::Dhtmem43, crate::common::RW> {
1280 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0408usize) as _) }
1281 }
1282 #[doc = "JPEG DHTMem tables"]
1283 #[inline(always)]
1284 pub const fn dhtmem44(self) -> crate::common::Reg<regs::Dhtmem44, crate::common::RW> {
1285 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x040cusize) as _) }
1286 }
1287 #[doc = "JPEG DHTMem tables"]
1288 #[inline(always)]
1289 pub const fn dhtmem45(self) -> crate::common::Reg<regs::Dhtmem45, crate::common::RW> {
1290 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0410usize) as _) }
1291 }
1292 #[doc = "JPEG DHTMem tables"]
1293 #[inline(always)]
1294 pub const fn dhtmem46(self) -> crate::common::Reg<regs::Dhtmem46, crate::common::RW> {
1295 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0414usize) as _) }
1296 }
1297 #[doc = "JPEG DHTMem tables"]
1298 #[inline(always)]
1299 pub const fn dhtmem47(self) -> crate::common::Reg<regs::Dhtmem47, crate::common::RW> {
1300 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0418usize) as _) }
1301 }
1302 #[doc = "JPEG DHTMem tables"]
1303 #[inline(always)]
1304 pub const fn dhtmem48(self) -> crate::common::Reg<regs::Dhtmem48, crate::common::RW> {
1305 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x041cusize) as _) }
1306 }
1307 #[doc = "JPEG DHTMem tables"]
1308 #[inline(always)]
1309 pub const fn dhtmem49(self) -> crate::common::Reg<regs::Dhtmem49, crate::common::RW> {
1310 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0420usize) as _) }
1311 }
1312 #[doc = "JPEG DHTMem tables"]
1313 #[inline(always)]
1314 pub const fn dhtmem50(self) -> crate::common::Reg<regs::Dhtmem50, crate::common::RW> {
1315 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0424usize) as _) }
1316 }
1317 #[doc = "JPEG DHTMem tables"]
1318 #[inline(always)]
1319 pub const fn dhtmem51(self) -> crate::common::Reg<regs::Dhtmem51, crate::common::RW> {
1320 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0428usize) as _) }
1321 }
1322 #[doc = "JPEG DHTMem tables"]
1323 #[inline(always)]
1324 pub const fn dhtmem52(self) -> crate::common::Reg<regs::Dhtmem52, crate::common::RW> {
1325 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x042cusize) as _) }
1326 }
1327 #[doc = "JPEG DHTMem tables"]
1328 #[inline(always)]
1329 pub const fn dhtmem53(self) -> crate::common::Reg<regs::Dhtmem53, crate::common::RW> {
1330 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0430usize) as _) }
1331 }
1332 #[doc = "JPEG DHTMem tables"]
1333 #[inline(always)]
1334 pub const fn dhtmem54(self) -> crate::common::Reg<regs::Dhtmem54, crate::common::RW> {
1335 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0434usize) as _) }
1336 }
1337 #[doc = "JPEG DHTMem tables"]
1338 #[inline(always)]
1339 pub const fn dhtmem55(self) -> crate::common::Reg<regs::Dhtmem55, crate::common::RW> {
1340 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0438usize) as _) }
1341 }
1342 #[doc = "JPEG DHTMem tables"]
1343 #[inline(always)]
1344 pub const fn dhtmem56(self) -> crate::common::Reg<regs::Dhtmem56, crate::common::RW> {
1345 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x043cusize) as _) }
1346 }
1347 #[doc = "JPEG DHTMem tables"]
1348 #[inline(always)]
1349 pub const fn dhtmem57(self) -> crate::common::Reg<regs::Dhtmem57, crate::common::RW> {
1350 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0440usize) as _) }
1351 }
1352 #[doc = "JPEG DHTMem tables"]
1353 #[inline(always)]
1354 pub const fn dhtmem58(self) -> crate::common::Reg<regs::Dhtmem58, crate::common::RW> {
1355 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0444usize) as _) }
1356 }
1357 #[doc = "JPEG DHTMem tables"]
1358 #[inline(always)]
1359 pub const fn dhtmem59(self) -> crate::common::Reg<regs::Dhtmem59, crate::common::RW> {
1360 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0448usize) as _) }
1361 }
1362 #[doc = "JPEG DHTMem tables"]
1363 #[inline(always)]
1364 pub const fn dhtmem60(self) -> crate::common::Reg<regs::Dhtmem60, crate::common::RW> {
1365 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x044cusize) as _) }
1366 }
1367 #[doc = "JPEG DHTMem tables"]
1368 #[inline(always)]
1369 pub const fn dhtmem61(self) -> crate::common::Reg<regs::Dhtmem61, crate::common::RW> {
1370 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0450usize) as _) }
1371 }
1372 #[doc = "JPEG DHTMem tables"]
1373 #[inline(always)]
1374 pub const fn dhtmem62(self) -> crate::common::Reg<regs::Dhtmem62, crate::common::RW> {
1375 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0454usize) as _) }
1376 }
1377 #[doc = "JPEG DHTMem tables"]
1378 #[inline(always)]
1379 pub const fn dhtmem63(self) -> crate::common::Reg<regs::Dhtmem63, crate::common::RW> {
1380 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0458usize) as _) }
1381 }
1382 #[doc = "JPEG DHTMem tables"]
1383 #[inline(always)]
1384 pub const fn dhtmem64(self) -> crate::common::Reg<regs::Dhtmem64, crate::common::RW> {
1385 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x045cusize) as _) }
1386 }
1387 #[doc = "JPEG DHTMem tables"]
1388 #[inline(always)]
1389 pub const fn dhtmem65(self) -> crate::common::Reg<regs::Dhtmem65, crate::common::RW> {
1390 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0460usize) as _) }
1391 }
1392 #[doc = "JPEG DHTMem tables"]
1393 #[inline(always)]
1394 pub const fn dhtmem66(self) -> crate::common::Reg<regs::Dhtmem66, crate::common::RW> {
1395 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0464usize) as _) }
1396 }
1397 #[doc = "JPEG DHTMem tables"]
1398 #[inline(always)]
1399 pub const fn dhtmem67(self) -> crate::common::Reg<regs::Dhtmem67, crate::common::RW> {
1400 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0468usize) as _) }
1401 }
1402 #[doc = "JPEG DHTMem tables"]
1403 #[inline(always)]
1404 pub const fn dhtmem68(self) -> crate::common::Reg<regs::Dhtmem68, crate::common::RW> {
1405 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x046cusize) as _) }
1406 }
1407 #[doc = "JPEG DHTMem tables"]
1408 #[inline(always)]
1409 pub const fn dhtmem69(self) -> crate::common::Reg<regs::Dhtmem69, crate::common::RW> {
1410 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0470usize) as _) }
1411 }
1412 #[doc = "JPEG DHTMem tables"]
1413 #[inline(always)]
1414 pub const fn dhtmem70(self) -> crate::common::Reg<regs::Dhtmem70, crate::common::RW> {
1415 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0474usize) as _) }
1416 }
1417 #[doc = "JPEG DHTMem tables"]
1418 #[inline(always)]
1419 pub const fn dhtmem71(self) -> crate::common::Reg<regs::Dhtmem71, crate::common::RW> {
1420 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0478usize) as _) }
1421 }
1422 #[doc = "JPEG DHTMem tables"]
1423 #[inline(always)]
1424 pub const fn dhtmem72(self) -> crate::common::Reg<regs::Dhtmem72, crate::common::RW> {
1425 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x047cusize) as _) }
1426 }
1427 #[doc = "JPEG DHTMem tables"]
1428 #[inline(always)]
1429 pub const fn dhtmem73(self) -> crate::common::Reg<regs::Dhtmem73, crate::common::RW> {
1430 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0480usize) as _) }
1431 }
1432 #[doc = "JPEG DHTMem tables"]
1433 #[inline(always)]
1434 pub const fn dhtmem74(self) -> crate::common::Reg<regs::Dhtmem74, crate::common::RW> {
1435 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0484usize) as _) }
1436 }
1437 #[doc = "JPEG DHTMem tables"]
1438 #[inline(always)]
1439 pub const fn dhtmem75(self) -> crate::common::Reg<regs::Dhtmem75, crate::common::RW> {
1440 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0488usize) as _) }
1441 }
1442 #[doc = "JPEG DHTMem tables"]
1443 #[inline(always)]
1444 pub const fn dhtmem76(self) -> crate::common::Reg<regs::Dhtmem76, crate::common::RW> {
1445 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x048cusize) as _) }
1446 }
1447 #[doc = "JPEG DHTMem tables"]
1448 #[inline(always)]
1449 pub const fn dhtmem77(self) -> crate::common::Reg<regs::Dhtmem77, crate::common::RW> {
1450 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0490usize) as _) }
1451 }
1452 #[doc = "JPEG DHTMem tables"]
1453 #[inline(always)]
1454 pub const fn dhtmem78(self) -> crate::common::Reg<regs::Dhtmem78, crate::common::RW> {
1455 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0494usize) as _) }
1456 }
1457 #[doc = "JPEG DHTMem tables"]
1458 #[inline(always)]
1459 pub const fn dhtmem79(self) -> crate::common::Reg<regs::Dhtmem79, crate::common::RW> {
1460 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0498usize) as _) }
1461 }
1462 #[doc = "JPEG DHTMem tables"]
1463 #[inline(always)]
1464 pub const fn dhtmem80(self) -> crate::common::Reg<regs::Dhtmem80, crate::common::RW> {
1465 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x049cusize) as _) }
1466 }
1467 #[doc = "JPEG DHTMem tables"]
1468 #[inline(always)]
1469 pub const fn dhtmem81(self) -> crate::common::Reg<regs::Dhtmem81, crate::common::RW> {
1470 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04a0usize) as _) }
1471 }
1472 #[doc = "JPEG DHTMem tables"]
1473 #[inline(always)]
1474 pub const fn dhtmem82(self) -> crate::common::Reg<regs::Dhtmem82, crate::common::RW> {
1475 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04a4usize) as _) }
1476 }
1477 #[doc = "JPEG DHTMem tables"]
1478 #[inline(always)]
1479 pub const fn dhtmem83(self) -> crate::common::Reg<regs::Dhtmem83, crate::common::RW> {
1480 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04a8usize) as _) }
1481 }
1482 #[doc = "JPEG DHTMem tables"]
1483 #[inline(always)]
1484 pub const fn dhtmem84(self) -> crate::common::Reg<regs::Dhtmem84, crate::common::RW> {
1485 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04acusize) as _) }
1486 }
1487 #[doc = "JPEG DHTMem tables"]
1488 #[inline(always)]
1489 pub const fn dhtmem85(self) -> crate::common::Reg<regs::Dhtmem85, crate::common::RW> {
1490 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04b0usize) as _) }
1491 }
1492 #[doc = "JPEG DHTMem tables"]
1493 #[inline(always)]
1494 pub const fn dhtmem86(self) -> crate::common::Reg<regs::Dhtmem86, crate::common::RW> {
1495 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04b4usize) as _) }
1496 }
1497 #[doc = "JPEG DHTMem tables"]
1498 #[inline(always)]
1499 pub const fn dhtmem87(self) -> crate::common::Reg<regs::Dhtmem87, crate::common::RW> {
1500 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04b8usize) as _) }
1501 }
1502 #[doc = "JPEG DHTMem tables"]
1503 #[inline(always)]
1504 pub const fn dhtmem88(self) -> crate::common::Reg<regs::Dhtmem88, crate::common::RW> {
1505 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04bcusize) as _) }
1506 }
1507 #[doc = "JPEG DHTMem tables"]
1508 #[inline(always)]
1509 pub const fn dhtmem89(self) -> crate::common::Reg<regs::Dhtmem89, crate::common::RW> {
1510 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04c0usize) as _) }
1511 }
1512 #[doc = "JPEG DHTMem tables"]
1513 #[inline(always)]
1514 pub const fn dhtmem90(self) -> crate::common::Reg<regs::Dhtmem90, crate::common::RW> {
1515 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04c4usize) as _) }
1516 }
1517 #[doc = "JPEG DHTMem tables"]
1518 #[inline(always)]
1519 pub const fn dhtmem91(self) -> crate::common::Reg<regs::Dhtmem91, crate::common::RW> {
1520 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04c8usize) as _) }
1521 }
1522 #[doc = "JPEG DHTMem tables"]
1523 #[inline(always)]
1524 pub const fn dhtmem92(self) -> crate::common::Reg<regs::Dhtmem92, crate::common::RW> {
1525 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04ccusize) as _) }
1526 }
1527 #[doc = "JPEG DHTMem tables"]
1528 #[inline(always)]
1529 pub const fn dhtmem93(self) -> crate::common::Reg<regs::Dhtmem93, crate::common::RW> {
1530 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04d0usize) as _) }
1531 }
1532 #[doc = "JPEG DHTMem tables"]
1533 #[inline(always)]
1534 pub const fn dhtmem94(self) -> crate::common::Reg<regs::Dhtmem94, crate::common::RW> {
1535 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04d4usize) as _) }
1536 }
1537 #[doc = "JPEG DHTMem tables"]
1538 #[inline(always)]
1539 pub const fn dhtmem95(self) -> crate::common::Reg<regs::Dhtmem95, crate::common::RW> {
1540 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04d8usize) as _) }
1541 }
1542 #[doc = "JPEG DHTMem tables"]
1543 #[inline(always)]
1544 pub const fn dhtmem96(self) -> crate::common::Reg<regs::Dhtmem96, crate::common::RW> {
1545 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04dcusize) as _) }
1546 }
1547 #[doc = "JPEG DHTMem tables"]
1548 #[inline(always)]
1549 pub const fn dhtmem97(self) -> crate::common::Reg<regs::Dhtmem97, crate::common::RW> {
1550 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04e0usize) as _) }
1551 }
1552 #[doc = "JPEG DHTMem tables"]
1553 #[inline(always)]
1554 pub const fn dhtmem98(self) -> crate::common::Reg<regs::Dhtmem98, crate::common::RW> {
1555 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04e4usize) as _) }
1556 }
1557 #[doc = "JPEG DHTMem tables"]
1558 #[inline(always)]
1559 pub const fn dhtmem99(self) -> crate::common::Reg<regs::Dhtmem99, crate::common::RW> {
1560 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04e8usize) as _) }
1561 }
1562 #[doc = "JPEG DHTMem tables"]
1563 #[inline(always)]
1564 pub const fn dhtmem100(self) -> crate::common::Reg<regs::Dhtmem100, crate::common::RW> {
1565 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04ecusize) as _) }
1566 }
1567 #[doc = "JPEG DHTMem tables"]
1568 #[inline(always)]
1569 pub const fn dhtmem101(self) -> crate::common::Reg<regs::Dhtmem101, crate::common::RW> {
1570 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04f0usize) as _) }
1571 }
1572 #[doc = "JPEG DHTMem tables"]
1573 #[inline(always)]
1574 pub const fn dhtmem102(self) -> crate::common::Reg<regs::Dhtmem102, crate::common::RW> {
1575 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04f4usize) as _) }
1576 }
1577 #[doc = "JPEG DHTMem tables"]
1578 #[inline(always)]
1579 pub const fn dhtmem103(self) -> crate::common::Reg<regs::Dhtmem103, crate::common::RW> {
1580 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04f8usize) as _) }
1581 }
1582 #[doc = "JPEG encoder, AC Huffman table 0"]
1583 #[inline(always)]
1584 pub const fn huffenc_ac0_0(self) -> crate::common::Reg<regs::HuffencAc00, crate::common::RW> {
1585 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0500usize) as _) }
1586 }
1587 #[doc = "JPEG encoder, AC Huffman table 0"]
1588 #[inline(always)]
1589 pub const fn huffenc_ac0_1(self) -> crate::common::Reg<regs::HuffencAc01, crate::common::RW> {
1590 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0504usize) as _) }
1591 }
1592 #[doc = "JPEG encoder, AC Huffman table 0"]
1593 #[inline(always)]
1594 pub const fn huffenc_ac0_2(self) -> crate::common::Reg<regs::HuffencAc02, crate::common::RW> {
1595 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0508usize) as _) }
1596 }
1597 #[doc = "JPEG encoder, AC Huffman table 0"]
1598 #[inline(always)]
1599 pub const fn huffenc_ac0_3(self) -> crate::common::Reg<regs::HuffencAc03, crate::common::RW> {
1600 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x050cusize) as _) }
1601 }
1602 #[doc = "JPEG encoder, AC Huffman table 0"]
1603 #[inline(always)]
1604 pub const fn huffenc_ac0_4(self) -> crate::common::Reg<regs::HuffencAc04, crate::common::RW> {
1605 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0510usize) as _) }
1606 }
1607 #[doc = "JPEG encoder, AC Huffman table 0"]
1608 #[inline(always)]
1609 pub const fn huffenc_ac0_5(self) -> crate::common::Reg<regs::HuffencAc05, crate::common::RW> {
1610 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0514usize) as _) }
1611 }
1612 #[doc = "JPEG encoder, AC Huffman table 0"]
1613 #[inline(always)]
1614 pub const fn huffenc_ac0_6(self) -> crate::common::Reg<regs::HuffencAc06, crate::common::RW> {
1615 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0518usize) as _) }
1616 }
1617 #[doc = "JPEG encoder, AC Huffman table 0"]
1618 #[inline(always)]
1619 pub const fn huffenc_ac0_7(self) -> crate::common::Reg<regs::HuffencAc07, crate::common::RW> {
1620 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x051cusize) as _) }
1621 }
1622 #[doc = "JPEG encoder, AC Huffman table 0"]
1623 #[inline(always)]
1624 pub const fn huffenc_ac0_8(self) -> crate::common::Reg<regs::HuffencAc08, crate::common::RW> {
1625 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0520usize) as _) }
1626 }
1627 #[doc = "JPEG encoder, AC Huffman table 0"]
1628 #[inline(always)]
1629 pub const fn huffenc_ac0_9(self) -> crate::common::Reg<regs::HuffencAc09, crate::common::RW> {
1630 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0524usize) as _) }
1631 }
1632 #[doc = "JPEG encoder, AC Huffman table 0"]
1633 #[inline(always)]
1634 pub const fn huffenc_ac0_10(self) -> crate::common::Reg<regs::HuffencAc010, crate::common::RW> {
1635 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0528usize) as _) }
1636 }
1637 #[doc = "JPEG encoder, AC Huffman table 0"]
1638 #[inline(always)]
1639 pub const fn huffenc_ac0_11(self) -> crate::common::Reg<regs::HuffencAc011, crate::common::RW> {
1640 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x052cusize) as _) }
1641 }
1642 #[doc = "JPEG encoder, AC Huffman table 0"]
1643 #[inline(always)]
1644 pub const fn huffenc_ac0_12(self) -> crate::common::Reg<regs::HuffencAc012, crate::common::RW> {
1645 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0530usize) as _) }
1646 }
1647 #[doc = "JPEG encoder, AC Huffman table 0"]
1648 #[inline(always)]
1649 pub const fn huffenc_ac0_13(self) -> crate::common::Reg<regs::HuffencAc013, crate::common::RW> {
1650 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0534usize) as _) }
1651 }
1652 #[doc = "JPEG encoder, AC Huffman table 0"]
1653 #[inline(always)]
1654 pub const fn huffenc_ac0_14(self) -> crate::common::Reg<regs::HuffencAc014, crate::common::RW> {
1655 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0538usize) as _) }
1656 }
1657 #[doc = "JPEG encoder, AC Huffman table 0"]
1658 #[inline(always)]
1659 pub const fn huffenc_ac0_15(self) -> crate::common::Reg<regs::HuffencAc015, crate::common::RW> {
1660 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x053cusize) as _) }
1661 }
1662 #[doc = "JPEG encoder, AC Huffman table 0"]
1663 #[inline(always)]
1664 pub const fn huffenc_ac0_16(self) -> crate::common::Reg<regs::HuffencAc016, crate::common::RW> {
1665 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0540usize) as _) }
1666 }
1667 #[doc = "JPEG encoder, AC Huffman table 0"]
1668 #[inline(always)]
1669 pub const fn huffenc_ac0_17(self) -> crate::common::Reg<regs::HuffencAc017, crate::common::RW> {
1670 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0544usize) as _) }
1671 }
1672 #[doc = "JPEG encoder, AC Huffman table 0"]
1673 #[inline(always)]
1674 pub const fn huffenc_ac0_18(self) -> crate::common::Reg<regs::HuffencAc018, crate::common::RW> {
1675 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0548usize) as _) }
1676 }
1677 #[doc = "JPEG encoder, AC Huffman table 0"]
1678 #[inline(always)]
1679 pub const fn huffenc_ac0_19(self) -> crate::common::Reg<regs::HuffencAc019, crate::common::RW> {
1680 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x054cusize) as _) }
1681 }
1682 #[doc = "JPEG encoder, AC Huffman table 0"]
1683 #[inline(always)]
1684 pub const fn huffenc_ac0_20(self) -> crate::common::Reg<regs::HuffencAc020, crate::common::RW> {
1685 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0550usize) as _) }
1686 }
1687 #[doc = "JPEG encoder, AC Huffman table 0"]
1688 #[inline(always)]
1689 pub const fn huffenc_ac0_21(self) -> crate::common::Reg<regs::HuffencAc021, crate::common::RW> {
1690 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0554usize) as _) }
1691 }
1692 #[doc = "JPEG encoder, AC Huffman table 0"]
1693 #[inline(always)]
1694 pub const fn huffenc_ac0_22(self) -> crate::common::Reg<regs::HuffencAc022, crate::common::RW> {
1695 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0558usize) as _) }
1696 }
1697 #[doc = "JPEG encoder, AC Huffman table 0"]
1698 #[inline(always)]
1699 pub const fn huffenc_ac0_23(self) -> crate::common::Reg<regs::HuffencAc023, crate::common::RW> {
1700 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x055cusize) as _) }
1701 }
1702 #[doc = "JPEG encoder, AC Huffman table 0"]
1703 #[inline(always)]
1704 pub const fn huffenc_ac0_24(self) -> crate::common::Reg<regs::HuffencAc024, crate::common::RW> {
1705 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0560usize) as _) }
1706 }
1707 #[doc = "JPEG encoder, AC Huffman table 0"]
1708 #[inline(always)]
1709 pub const fn huffenc_ac0_25(self) -> crate::common::Reg<regs::HuffencAc025, crate::common::RW> {
1710 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0564usize) as _) }
1711 }
1712 #[doc = "JPEG encoder, AC Huffman table 0"]
1713 #[inline(always)]
1714 pub const fn huffenc_ac0_26(self) -> crate::common::Reg<regs::HuffencAc026, crate::common::RW> {
1715 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0568usize) as _) }
1716 }
1717 #[doc = "JPEG encoder, AC Huffman table 0"]
1718 #[inline(always)]
1719 pub const fn huffenc_ac0_27(self) -> crate::common::Reg<regs::HuffencAc027, crate::common::RW> {
1720 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x056cusize) as _) }
1721 }
1722 #[doc = "JPEG encoder, AC Huffman table 0"]
1723 #[inline(always)]
1724 pub const fn huffenc_ac0_28(self) -> crate::common::Reg<regs::HuffencAc028, crate::common::RW> {
1725 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0570usize) as _) }
1726 }
1727 #[doc = "JPEG encoder, AC Huffman table 0"]
1728 #[inline(always)]
1729 pub const fn huffenc_ac0_29(self) -> crate::common::Reg<regs::HuffencAc029, crate::common::RW> {
1730 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0574usize) as _) }
1731 }
1732 #[doc = "JPEG encoder, AC Huffman table 0"]
1733 #[inline(always)]
1734 pub const fn huffenc_ac0_30(self) -> crate::common::Reg<regs::HuffencAc030, crate::common::RW> {
1735 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0578usize) as _) }
1736 }
1737 #[doc = "JPEG encoder, AC Huffman table 0"]
1738 #[inline(always)]
1739 pub const fn huffenc_ac0_31(self) -> crate::common::Reg<regs::HuffencAc031, crate::common::RW> {
1740 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x057cusize) as _) }
1741 }
1742 #[doc = "JPEG encoder, AC Huffman table 0"]
1743 #[inline(always)]
1744 pub const fn huffenc_ac0_32(self) -> crate::common::Reg<regs::HuffencAc032, crate::common::RW> {
1745 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0580usize) as _) }
1746 }
1747 #[doc = "JPEG encoder, AC Huffman table 0"]
1748 #[inline(always)]
1749 pub const fn huffenc_ac0_33(self) -> crate::common::Reg<regs::HuffencAc033, crate::common::RW> {
1750 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0584usize) as _) }
1751 }
1752 #[doc = "JPEG encoder, AC Huffman table 0"]
1753 #[inline(always)]
1754 pub const fn huffenc_ac0_34(self) -> crate::common::Reg<regs::HuffencAc034, crate::common::RW> {
1755 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0588usize) as _) }
1756 }
1757 #[doc = "JPEG encoder, AC Huffman table 0"]
1758 #[inline(always)]
1759 pub const fn huffenc_ac0_35(self) -> crate::common::Reg<regs::HuffencAc035, crate::common::RW> {
1760 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x058cusize) as _) }
1761 }
1762 #[doc = "JPEG encoder, AC Huffman table 0"]
1763 #[inline(always)]
1764 pub const fn huffenc_ac0_36(self) -> crate::common::Reg<regs::HuffencAc036, crate::common::RW> {
1765 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0590usize) as _) }
1766 }
1767 #[doc = "JPEG encoder, AC Huffman table 0"]
1768 #[inline(always)]
1769 pub const fn huffenc_ac0_37(self) -> crate::common::Reg<regs::HuffencAc037, crate::common::RW> {
1770 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0594usize) as _) }
1771 }
1772 #[doc = "JPEG encoder, AC Huffman table 0"]
1773 #[inline(always)]
1774 pub const fn huffenc_ac0_38(self) -> crate::common::Reg<regs::HuffencAc038, crate::common::RW> {
1775 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0598usize) as _) }
1776 }
1777 #[doc = "JPEG encoder, AC Huffman table 0"]
1778 #[inline(always)]
1779 pub const fn huffenc_ac0_39(self) -> crate::common::Reg<regs::HuffencAc039, crate::common::RW> {
1780 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x059cusize) as _) }
1781 }
1782 #[doc = "JPEG encoder, AC Huffman table 0"]
1783 #[inline(always)]
1784 pub const fn huffenc_ac0_40(self) -> crate::common::Reg<regs::HuffencAc040, crate::common::RW> {
1785 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05a0usize) as _) }
1786 }
1787 #[doc = "JPEG encoder, AC Huffman table 0"]
1788 #[inline(always)]
1789 pub const fn huffenc_ac0_41(self) -> crate::common::Reg<regs::HuffencAc041, crate::common::RW> {
1790 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05a4usize) as _) }
1791 }
1792 #[doc = "JPEG encoder, AC Huffman table 0"]
1793 #[inline(always)]
1794 pub const fn huffenc_ac0_42(self) -> crate::common::Reg<regs::HuffencAc042, crate::common::RW> {
1795 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05a8usize) as _) }
1796 }
1797 #[doc = "JPEG encoder, AC Huffman table 0"]
1798 #[inline(always)]
1799 pub const fn huffenc_ac0_43(self) -> crate::common::Reg<regs::HuffencAc043, crate::common::RW> {
1800 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05acusize) as _) }
1801 }
1802 #[doc = "JPEG encoder, AC Huffman table 0"]
1803 #[inline(always)]
1804 pub const fn huffenc_ac0_44(self) -> crate::common::Reg<regs::HuffencAc044, crate::common::RW> {
1805 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05b0usize) as _) }
1806 }
1807 #[doc = "JPEG encoder, AC Huffman table 0"]
1808 #[inline(always)]
1809 pub const fn huffenc_ac0_45(self) -> crate::common::Reg<regs::HuffencAc045, crate::common::RW> {
1810 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05b4usize) as _) }
1811 }
1812 #[doc = "JPEG encoder, AC Huffman table 0"]
1813 #[inline(always)]
1814 pub const fn huffenc_ac0_46(self) -> crate::common::Reg<regs::HuffencAc046, crate::common::RW> {
1815 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05b8usize) as _) }
1816 }
1817 #[doc = "JPEG encoder, AC Huffman table 0"]
1818 #[inline(always)]
1819 pub const fn huffenc_ac0_47(self) -> crate::common::Reg<regs::HuffencAc047, crate::common::RW> {
1820 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05bcusize) as _) }
1821 }
1822 #[doc = "JPEG encoder, AC Huffman table 0"]
1823 #[inline(always)]
1824 pub const fn huffenc_ac0_48(self) -> crate::common::Reg<regs::HuffencAc048, crate::common::RW> {
1825 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05c0usize) as _) }
1826 }
1827 #[doc = "JPEG encoder, AC Huffman table 0"]
1828 #[inline(always)]
1829 pub const fn huffenc_ac0_49(self) -> crate::common::Reg<regs::HuffencAc049, crate::common::RW> {
1830 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05c4usize) as _) }
1831 }
1832 #[doc = "JPEG encoder, AC Huffman table 0"]
1833 #[inline(always)]
1834 pub const fn huffenc_ac0_50(self) -> crate::common::Reg<regs::HuffencAc050, crate::common::RW> {
1835 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05c8usize) as _) }
1836 }
1837 #[doc = "JPEG encoder, AC Huffman table 0"]
1838 #[inline(always)]
1839 pub const fn huffenc_ac0_51(self) -> crate::common::Reg<regs::HuffencAc051, crate::common::RW> {
1840 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05ccusize) as _) }
1841 }
1842 #[doc = "JPEG encoder, AC Huffman table 0"]
1843 #[inline(always)]
1844 pub const fn huffenc_ac0_52(self) -> crate::common::Reg<regs::HuffencAc052, crate::common::RW> {
1845 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05d0usize) as _) }
1846 }
1847 #[doc = "JPEG encoder, AC Huffman table 0"]
1848 #[inline(always)]
1849 pub const fn huffenc_ac0_53(self) -> crate::common::Reg<regs::HuffencAc053, crate::common::RW> {
1850 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05d4usize) as _) }
1851 }
1852 #[doc = "JPEG encoder, AC Huffman table 0"]
1853 #[inline(always)]
1854 pub const fn huffenc_ac0_54(self) -> crate::common::Reg<regs::HuffencAc054, crate::common::RW> {
1855 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05d8usize) as _) }
1856 }
1857 #[doc = "JPEG encoder, AC Huffman table 0"]
1858 #[inline(always)]
1859 pub const fn huffenc_ac0_55(self) -> crate::common::Reg<regs::HuffencAc055, crate::common::RW> {
1860 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05dcusize) as _) }
1861 }
1862 #[doc = "JPEG encoder, AC Huffman table 0"]
1863 #[inline(always)]
1864 pub const fn huffenc_ac0_56(self) -> crate::common::Reg<regs::HuffencAc056, crate::common::RW> {
1865 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05e0usize) as _) }
1866 }
1867 #[doc = "JPEG encoder, AC Huffman table 0"]
1868 #[inline(always)]
1869 pub const fn huffenc_ac0_57(self) -> crate::common::Reg<regs::HuffencAc057, crate::common::RW> {
1870 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05e4usize) as _) }
1871 }
1872 #[doc = "JPEG encoder, AC Huffman table 0"]
1873 #[inline(always)]
1874 pub const fn huffenc_ac0_58(self) -> crate::common::Reg<regs::HuffencAc058, crate::common::RW> {
1875 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05e8usize) as _) }
1876 }
1877 #[doc = "JPEG encoder, AC Huffman table 0"]
1878 #[inline(always)]
1879 pub const fn huffenc_ac0_59(self) -> crate::common::Reg<regs::HuffencAc059, crate::common::RW> {
1880 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05ecusize) as _) }
1881 }
1882 #[doc = "JPEG encoder, AC Huffman table 0"]
1883 #[inline(always)]
1884 pub const fn huffenc_ac0_60(self) -> crate::common::Reg<regs::HuffencAc060, crate::common::RW> {
1885 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05f0usize) as _) }
1886 }
1887 #[doc = "JPEG encoder, AC Huffman table 0"]
1888 #[inline(always)]
1889 pub const fn huffenc_ac0_61(self) -> crate::common::Reg<regs::HuffencAc061, crate::common::RW> {
1890 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05f4usize) as _) }
1891 }
1892 #[doc = "JPEG encoder, AC Huffman table 0"]
1893 #[inline(always)]
1894 pub const fn huffenc_ac0_62(self) -> crate::common::Reg<regs::HuffencAc062, crate::common::RW> {
1895 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05f8usize) as _) }
1896 }
1897 #[doc = "JPEG encoder, AC Huffman table 0"]
1898 #[inline(always)]
1899 pub const fn huffenc_ac0_63(self) -> crate::common::Reg<regs::HuffencAc063, crate::common::RW> {
1900 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x05fcusize) as _) }
1901 }
1902 #[doc = "JPEG encoder, AC Huffman table 0"]
1903 #[inline(always)]
1904 pub const fn huffenc_ac0_64(self) -> crate::common::Reg<regs::HuffencAc064, crate::common::RW> {
1905 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0600usize) as _) }
1906 }
1907 #[doc = "JPEG encoder, AC Huffman table 0"]
1908 #[inline(always)]
1909 pub const fn huffenc_ac0_65(self) -> crate::common::Reg<regs::HuffencAc065, crate::common::RW> {
1910 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0604usize) as _) }
1911 }
1912 #[doc = "JPEG encoder, AC Huffman table 0"]
1913 #[inline(always)]
1914 pub const fn huffenc_ac0_66(self) -> crate::common::Reg<regs::HuffencAc066, crate::common::RW> {
1915 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0608usize) as _) }
1916 }
1917 #[doc = "JPEG encoder, AC Huffman table 0"]
1918 #[inline(always)]
1919 pub const fn huffenc_ac0_67(self) -> crate::common::Reg<regs::HuffencAc067, crate::common::RW> {
1920 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x060cusize) as _) }
1921 }
1922 #[doc = "JPEG encoder, AC Huffman table 0"]
1923 #[inline(always)]
1924 pub const fn huffenc_ac0_68(self) -> crate::common::Reg<regs::HuffencAc068, crate::common::RW> {
1925 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0610usize) as _) }
1926 }
1927 #[doc = "JPEG encoder, AC Huffman table 0"]
1928 #[inline(always)]
1929 pub const fn huffenc_ac0_69(self) -> crate::common::Reg<regs::HuffencAc069, crate::common::RW> {
1930 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0614usize) as _) }
1931 }
1932 #[doc = "JPEG encoder, AC Huffman table 0"]
1933 #[inline(always)]
1934 pub const fn huffenc_ac0_70(self) -> crate::common::Reg<regs::HuffencAc070, crate::common::RW> {
1935 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0618usize) as _) }
1936 }
1937 #[doc = "JPEG encoder, AC Huffman table 0"]
1938 #[inline(always)]
1939 pub const fn huffenc_ac0_71(self) -> crate::common::Reg<regs::HuffencAc071, crate::common::RW> {
1940 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x061cusize) as _) }
1941 }
1942 #[doc = "JPEG encoder, AC Huffman table 0"]
1943 #[inline(always)]
1944 pub const fn huffenc_ac0_72(self) -> crate::common::Reg<regs::HuffencAc072, crate::common::RW> {
1945 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0620usize) as _) }
1946 }
1947 #[doc = "JPEG encoder, AC Huffman table 0"]
1948 #[inline(always)]
1949 pub const fn huffenc_ac0_73(self) -> crate::common::Reg<regs::HuffencAc073, crate::common::RW> {
1950 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0624usize) as _) }
1951 }
1952 #[doc = "JPEG encoder, AC Huffman table 0"]
1953 #[inline(always)]
1954 pub const fn huffenc_ac0_74(self) -> crate::common::Reg<regs::HuffencAc074, crate::common::RW> {
1955 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0628usize) as _) }
1956 }
1957 #[doc = "JPEG encoder, AC Huffman table 0"]
1958 #[inline(always)]
1959 pub const fn huffenc_ac0_75(self) -> crate::common::Reg<regs::HuffencAc075, crate::common::RW> {
1960 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x062cusize) as _) }
1961 }
1962 #[doc = "JPEG encoder, AC Huffman table 0"]
1963 #[inline(always)]
1964 pub const fn huffenc_ac0_76(self) -> crate::common::Reg<regs::HuffencAc076, crate::common::RW> {
1965 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0630usize) as _) }
1966 }
1967 #[doc = "JPEG encoder, AC Huffman table 0"]
1968 #[inline(always)]
1969 pub const fn huffenc_ac0_77(self) -> crate::common::Reg<regs::HuffencAc077, crate::common::RW> {
1970 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0634usize) as _) }
1971 }
1972 #[doc = "JPEG encoder, AC Huffman table 0"]
1973 #[inline(always)]
1974 pub const fn huffenc_ac0_78(self) -> crate::common::Reg<regs::HuffencAc078, crate::common::RW> {
1975 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0638usize) as _) }
1976 }
1977 #[doc = "JPEG encoder, AC Huffman table 0"]
1978 #[inline(always)]
1979 pub const fn huffenc_ac0_79(self) -> crate::common::Reg<regs::HuffencAc079, crate::common::RW> {
1980 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x063cusize) as _) }
1981 }
1982 #[doc = "JPEG encoder, AC Huffman table 0"]
1983 #[inline(always)]
1984 pub const fn huffenc_ac0_80(self) -> crate::common::Reg<regs::HuffencAc080, crate::common::RW> {
1985 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0640usize) as _) }
1986 }
1987 #[doc = "JPEG encoder, AC Huffman table 0"]
1988 #[inline(always)]
1989 pub const fn huffenc_ac0_81(self) -> crate::common::Reg<regs::HuffencAc081, crate::common::RW> {
1990 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0644usize) as _) }
1991 }
1992 #[doc = "JPEG encoder, AC Huffman table 0"]
1993 #[inline(always)]
1994 pub const fn huffenc_ac0_82(self) -> crate::common::Reg<regs::HuffencAc082, crate::common::RW> {
1995 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0648usize) as _) }
1996 }
1997 #[doc = "JPEG encoder, AC Huffman table 0"]
1998 #[inline(always)]
1999 pub const fn huffenc_ac0_83(self) -> crate::common::Reg<regs::HuffencAc083, crate::common::RW> {
2000 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x064cusize) as _) }
2001 }
2002 #[doc = "JPEG encoder, AC Huffman table 0"]
2003 #[inline(always)]
2004 pub const fn huffenc_ac0_84(self) -> crate::common::Reg<regs::HuffencAc084, crate::common::RW> {
2005 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0650usize) as _) }
2006 }
2007 #[doc = "JPEG encoder, AC Huffman table 0"]
2008 #[inline(always)]
2009 pub const fn huffenc_ac0_85(self) -> crate::common::Reg<regs::HuffencAc085, crate::common::RW> {
2010 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0654usize) as _) }
2011 }
2012 #[doc = "JPEG encoder, AC Huffman table 0"]
2013 #[inline(always)]
2014 pub const fn huffenc_ac0_86(self) -> crate::common::Reg<regs::HuffencAc086, crate::common::RW> {
2015 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0658usize) as _) }
2016 }
2017 #[doc = "JPEG encoder, AC Huffman table 0"]
2018 #[inline(always)]
2019 pub const fn huffenc_ac0_87(self) -> crate::common::Reg<regs::HuffencAc087, crate::common::RW> {
2020 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x065cusize) as _) }
2021 }
2022 #[doc = "JPEG encoder, AC Huffman table 1"]
2023 #[inline(always)]
2024 pub const fn huffenc_ac1_0(self) -> crate::common::Reg<regs::HuffencAc10, crate::common::RW> {
2025 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0660usize) as _) }
2026 }
2027 #[doc = "JPEG encoder, AC Huffman table 1"]
2028 #[inline(always)]
2029 pub const fn huffenc_ac1_1(self) -> crate::common::Reg<regs::HuffencAc11, crate::common::RW> {
2030 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0664usize) as _) }
2031 }
2032 #[doc = "JPEG encoder, AC Huffman table 1"]
2033 #[inline(always)]
2034 pub const fn huffenc_ac1_2(self) -> crate::common::Reg<regs::HuffencAc12, crate::common::RW> {
2035 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0668usize) as _) }
2036 }
2037 #[doc = "JPEG encoder, AC Huffman table 1"]
2038 #[inline(always)]
2039 pub const fn huffenc_ac1_3(self) -> crate::common::Reg<regs::HuffencAc13, crate::common::RW> {
2040 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x066cusize) as _) }
2041 }
2042 #[doc = "JPEG encoder, AC Huffman table 1"]
2043 #[inline(always)]
2044 pub const fn huffenc_ac1_4(self) -> crate::common::Reg<regs::HuffencAc14, crate::common::RW> {
2045 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0670usize) as _) }
2046 }
2047 #[doc = "JPEG encoder, AC Huffman table 1"]
2048 #[inline(always)]
2049 pub const fn huffenc_ac1_5(self) -> crate::common::Reg<regs::HuffencAc15, crate::common::RW> {
2050 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0674usize) as _) }
2051 }
2052 #[doc = "JPEG encoder, AC Huffman table 1"]
2053 #[inline(always)]
2054 pub const fn huffenc_ac1_6(self) -> crate::common::Reg<regs::HuffencAc16, crate::common::RW> {
2055 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0678usize) as _) }
2056 }
2057 #[doc = "JPEG encoder, AC Huffman table 1"]
2058 #[inline(always)]
2059 pub const fn huffenc_ac1_7(self) -> crate::common::Reg<regs::HuffencAc17, crate::common::RW> {
2060 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x067cusize) as _) }
2061 }
2062 #[doc = "JPEG encoder, AC Huffman table 1"]
2063 #[inline(always)]
2064 pub const fn huffenc_ac1_8(self) -> crate::common::Reg<regs::HuffencAc18, crate::common::RW> {
2065 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0680usize) as _) }
2066 }
2067 #[doc = "JPEG encoder, AC Huffman table 1"]
2068 #[inline(always)]
2069 pub const fn huffenc_ac1_9(self) -> crate::common::Reg<regs::HuffencAc19, crate::common::RW> {
2070 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0684usize) as _) }
2071 }
2072 #[doc = "JPEG encoder, AC Huffman table 1"]
2073 #[inline(always)]
2074 pub const fn huffenc_ac1_10(self) -> crate::common::Reg<regs::HuffencAc110, crate::common::RW> {
2075 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0688usize) as _) }
2076 }
2077 #[doc = "JPEG encoder, AC Huffman table 1"]
2078 #[inline(always)]
2079 pub const fn huffenc_ac1_11(self) -> crate::common::Reg<regs::HuffencAc111, crate::common::RW> {
2080 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x068cusize) as _) }
2081 }
2082 #[doc = "JPEG encoder, AC Huffman table 1"]
2083 #[inline(always)]
2084 pub const fn huffenc_ac1_12(self) -> crate::common::Reg<regs::HuffencAc112, crate::common::RW> {
2085 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0690usize) as _) }
2086 }
2087 #[doc = "JPEG encoder, AC Huffman table 1"]
2088 #[inline(always)]
2089 pub const fn huffenc_ac1_13(self) -> crate::common::Reg<regs::HuffencAc113, crate::common::RW> {
2090 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0694usize) as _) }
2091 }
2092 #[doc = "JPEG encoder, AC Huffman table 1"]
2093 #[inline(always)]
2094 pub const fn huffenc_ac1_14(self) -> crate::common::Reg<regs::HuffencAc114, crate::common::RW> {
2095 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0698usize) as _) }
2096 }
2097 #[doc = "JPEG encoder, AC Huffman table 1"]
2098 #[inline(always)]
2099 pub const fn huffenc_ac1_15(self) -> crate::common::Reg<regs::HuffencAc115, crate::common::RW> {
2100 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x069cusize) as _) }
2101 }
2102 #[doc = "JPEG encoder, AC Huffman table 1"]
2103 #[inline(always)]
2104 pub const fn huffenc_ac1_16(self) -> crate::common::Reg<regs::HuffencAc116, crate::common::RW> {
2105 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06a0usize) as _) }
2106 }
2107 #[doc = "JPEG encoder, AC Huffman table 1"]
2108 #[inline(always)]
2109 pub const fn huffenc_ac1_17(self) -> crate::common::Reg<regs::HuffencAc117, crate::common::RW> {
2110 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06a4usize) as _) }
2111 }
2112 #[doc = "JPEG encoder, AC Huffman table 1"]
2113 #[inline(always)]
2114 pub const fn huffenc_ac1_18(self) -> crate::common::Reg<regs::HuffencAc118, crate::common::RW> {
2115 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06a8usize) as _) }
2116 }
2117 #[doc = "JPEG encoder, AC Huffman table 1"]
2118 #[inline(always)]
2119 pub const fn huffenc_ac1_19(self) -> crate::common::Reg<regs::HuffencAc119, crate::common::RW> {
2120 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06acusize) as _) }
2121 }
2122 #[doc = "JPEG encoder, AC Huffman table 1"]
2123 #[inline(always)]
2124 pub const fn huffenc_ac1_20(self) -> crate::common::Reg<regs::HuffencAc120, crate::common::RW> {
2125 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06b0usize) as _) }
2126 }
2127 #[doc = "JPEG encoder, AC Huffman table 1"]
2128 #[inline(always)]
2129 pub const fn huffenc_ac1_21(self) -> crate::common::Reg<regs::HuffencAc121, crate::common::RW> {
2130 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06b4usize) as _) }
2131 }
2132 #[doc = "JPEG encoder, AC Huffman table 1"]
2133 #[inline(always)]
2134 pub const fn huffenc_ac1_22(self) -> crate::common::Reg<regs::HuffencAc122, crate::common::RW> {
2135 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06b8usize) as _) }
2136 }
2137 #[doc = "JPEG encoder, AC Huffman table 1"]
2138 #[inline(always)]
2139 pub const fn huffenc_ac1_23(self) -> crate::common::Reg<regs::HuffencAc123, crate::common::RW> {
2140 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06bcusize) as _) }
2141 }
2142 #[doc = "JPEG encoder, AC Huffman table 1"]
2143 #[inline(always)]
2144 pub const fn huffenc_ac1_24(self) -> crate::common::Reg<regs::HuffencAc124, crate::common::RW> {
2145 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06c0usize) as _) }
2146 }
2147 #[doc = "JPEG encoder, AC Huffman table 1"]
2148 #[inline(always)]
2149 pub const fn huffenc_ac1_25(self) -> crate::common::Reg<regs::HuffencAc125, crate::common::RW> {
2150 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06c4usize) as _) }
2151 }
2152 #[doc = "JPEG encoder, AC Huffman table 1"]
2153 #[inline(always)]
2154 pub const fn huffenc_ac1_26(self) -> crate::common::Reg<regs::HuffencAc126, crate::common::RW> {
2155 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06c8usize) as _) }
2156 }
2157 #[doc = "JPEG encoder, AC Huffman table 1"]
2158 #[inline(always)]
2159 pub const fn huffenc_ac1_27(self) -> crate::common::Reg<regs::HuffencAc127, crate::common::RW> {
2160 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06ccusize) as _) }
2161 }
2162 #[doc = "JPEG encoder, AC Huffman table 1"]
2163 #[inline(always)]
2164 pub const fn huffenc_ac1_28(self) -> crate::common::Reg<regs::HuffencAc128, crate::common::RW> {
2165 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06d0usize) as _) }
2166 }
2167 #[doc = "JPEG encoder, AC Huffman table 1"]
2168 #[inline(always)]
2169 pub const fn huffenc_ac1_29(self) -> crate::common::Reg<regs::HuffencAc129, crate::common::RW> {
2170 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06d4usize) as _) }
2171 }
2172 #[doc = "JPEG encoder, AC Huffman table 1"]
2173 #[inline(always)]
2174 pub const fn huffenc_ac1_30(self) -> crate::common::Reg<regs::HuffencAc130, crate::common::RW> {
2175 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06d8usize) as _) }
2176 }
2177 #[doc = "JPEG encoder, AC Huffman table 1"]
2178 #[inline(always)]
2179 pub const fn huffenc_ac1_31(self) -> crate::common::Reg<regs::HuffencAc131, crate::common::RW> {
2180 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06dcusize) as _) }
2181 }
2182 #[doc = "JPEG encoder, AC Huffman table 1"]
2183 #[inline(always)]
2184 pub const fn huffenc_ac1_32(self) -> crate::common::Reg<regs::HuffencAc132, crate::common::RW> {
2185 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06e0usize) as _) }
2186 }
2187 #[doc = "JPEG encoder, AC Huffman table 1"]
2188 #[inline(always)]
2189 pub const fn huffenc_ac1_33(self) -> crate::common::Reg<regs::HuffencAc133, crate::common::RW> {
2190 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06e4usize) as _) }
2191 }
2192 #[doc = "JPEG encoder, AC Huffman table 1"]
2193 #[inline(always)]
2194 pub const fn huffenc_ac1_34(self) -> crate::common::Reg<regs::HuffencAc134, crate::common::RW> {
2195 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06e8usize) as _) }
2196 }
2197 #[doc = "JPEG encoder, AC Huffman table 1"]
2198 #[inline(always)]
2199 pub const fn huffenc_ac1_35(self) -> crate::common::Reg<regs::HuffencAc135, crate::common::RW> {
2200 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06ecusize) as _) }
2201 }
2202 #[doc = "JPEG encoder, AC Huffman table 1"]
2203 #[inline(always)]
2204 pub const fn huffenc_ac1_36(self) -> crate::common::Reg<regs::HuffencAc136, crate::common::RW> {
2205 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06f0usize) as _) }
2206 }
2207 #[doc = "JPEG encoder, AC Huffman table 1"]
2208 #[inline(always)]
2209 pub const fn huffenc_ac1_37(self) -> crate::common::Reg<regs::HuffencAc137, crate::common::RW> {
2210 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06f4usize) as _) }
2211 }
2212 #[doc = "JPEG encoder, AC Huffman table 1"]
2213 #[inline(always)]
2214 pub const fn huffenc_ac1_38(self) -> crate::common::Reg<regs::HuffencAc138, crate::common::RW> {
2215 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06f8usize) as _) }
2216 }
2217 #[doc = "JPEG encoder, AC Huffman table 1"]
2218 #[inline(always)]
2219 pub const fn huffenc_ac1_39(self) -> crate::common::Reg<regs::HuffencAc139, crate::common::RW> {
2220 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x06fcusize) as _) }
2221 }
2222 #[doc = "JPEG encoder, AC Huffman table 1"]
2223 #[inline(always)]
2224 pub const fn huffenc_ac1_40(self) -> crate::common::Reg<regs::HuffencAc140, crate::common::RW> {
2225 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0700usize) as _) }
2226 }
2227 #[doc = "JPEG encoder, AC Huffman table 1"]
2228 #[inline(always)]
2229 pub const fn huffenc_ac1_41(self) -> crate::common::Reg<regs::HuffencAc141, crate::common::RW> {
2230 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0704usize) as _) }
2231 }
2232 #[doc = "JPEG encoder, AC Huffman table 1"]
2233 #[inline(always)]
2234 pub const fn huffenc_ac1_42(self) -> crate::common::Reg<regs::HuffencAc142, crate::common::RW> {
2235 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0708usize) as _) }
2236 }
2237 #[doc = "JPEG encoder, AC Huffman table 1"]
2238 #[inline(always)]
2239 pub const fn huffenc_ac1_43(self) -> crate::common::Reg<regs::HuffencAc143, crate::common::RW> {
2240 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x070cusize) as _) }
2241 }
2242 #[doc = "JPEG encoder, AC Huffman table 1"]
2243 #[inline(always)]
2244 pub const fn huffenc_ac1_44(self) -> crate::common::Reg<regs::HuffencAc144, crate::common::RW> {
2245 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0710usize) as _) }
2246 }
2247 #[doc = "JPEG encoder, AC Huffman table 1"]
2248 #[inline(always)]
2249 pub const fn huffenc_ac1_45(self) -> crate::common::Reg<regs::HuffencAc145, crate::common::RW> {
2250 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0714usize) as _) }
2251 }
2252 #[doc = "JPEG encoder, AC Huffman table 1"]
2253 #[inline(always)]
2254 pub const fn huffenc_ac1_46(self) -> crate::common::Reg<regs::HuffencAc146, crate::common::RW> {
2255 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0718usize) as _) }
2256 }
2257 #[doc = "JPEG encoder, AC Huffman table 1"]
2258 #[inline(always)]
2259 pub const fn huffenc_ac1_47(self) -> crate::common::Reg<regs::HuffencAc147, crate::common::RW> {
2260 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x071cusize) as _) }
2261 }
2262 #[doc = "JPEG encoder, AC Huffman table 1"]
2263 #[inline(always)]
2264 pub const fn huffenc_ac1_48(self) -> crate::common::Reg<regs::HuffencAc148, crate::common::RW> {
2265 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0720usize) as _) }
2266 }
2267 #[doc = "JPEG encoder, AC Huffman table 1"]
2268 #[inline(always)]
2269 pub const fn huffenc_ac1_49(self) -> crate::common::Reg<regs::HuffencAc149, crate::common::RW> {
2270 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0724usize) as _) }
2271 }
2272 #[doc = "JPEG encoder, AC Huffman table 1"]
2273 #[inline(always)]
2274 pub const fn huffenc_ac1_50(self) -> crate::common::Reg<regs::HuffencAc150, crate::common::RW> {
2275 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0728usize) as _) }
2276 }
2277 #[doc = "JPEG encoder, AC Huffman table 1"]
2278 #[inline(always)]
2279 pub const fn huffenc_ac1_51(self) -> crate::common::Reg<regs::HuffencAc151, crate::common::RW> {
2280 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x072cusize) as _) }
2281 }
2282 #[doc = "JPEG encoder, AC Huffman table 1"]
2283 #[inline(always)]
2284 pub const fn huffenc_ac1_52(self) -> crate::common::Reg<regs::HuffencAc152, crate::common::RW> {
2285 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0730usize) as _) }
2286 }
2287 #[doc = "JPEG encoder, AC Huffman table 1"]
2288 #[inline(always)]
2289 pub const fn huffenc_ac1_53(self) -> crate::common::Reg<regs::HuffencAc153, crate::common::RW> {
2290 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0734usize) as _) }
2291 }
2292 #[doc = "JPEG encoder, AC Huffman table 1"]
2293 #[inline(always)]
2294 pub const fn huffenc_ac1_54(self) -> crate::common::Reg<regs::HuffencAc154, crate::common::RW> {
2295 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0738usize) as _) }
2296 }
2297 #[doc = "JPEG encoder, AC Huffman table 1"]
2298 #[inline(always)]
2299 pub const fn huffenc_ac1_55(self) -> crate::common::Reg<regs::HuffencAc155, crate::common::RW> {
2300 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x073cusize) as _) }
2301 }
2302 #[doc = "JPEG encoder, AC Huffman table 1"]
2303 #[inline(always)]
2304 pub const fn huffenc_ac1_56(self) -> crate::common::Reg<regs::HuffencAc156, crate::common::RW> {
2305 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0740usize) as _) }
2306 }
2307 #[doc = "JPEG encoder, AC Huffman table 1"]
2308 #[inline(always)]
2309 pub const fn huffenc_ac1_57(self) -> crate::common::Reg<regs::HuffencAc157, crate::common::RW> {
2310 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0744usize) as _) }
2311 }
2312 #[doc = "JPEG encoder, AC Huffman table 1"]
2313 #[inline(always)]
2314 pub const fn huffenc_ac1_58(self) -> crate::common::Reg<regs::HuffencAc158, crate::common::RW> {
2315 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0748usize) as _) }
2316 }
2317 #[doc = "JPEG encoder, AC Huffman table 1"]
2318 #[inline(always)]
2319 pub const fn huffenc_ac1_59(self) -> crate::common::Reg<regs::HuffencAc159, crate::common::RW> {
2320 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x074cusize) as _) }
2321 }
2322 #[doc = "JPEG encoder, AC Huffman table 1"]
2323 #[inline(always)]
2324 pub const fn huffenc_ac1_60(self) -> crate::common::Reg<regs::HuffencAc160, crate::common::RW> {
2325 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0750usize) as _) }
2326 }
2327 #[doc = "JPEG encoder, AC Huffman table 1"]
2328 #[inline(always)]
2329 pub const fn huffenc_ac1_61(self) -> crate::common::Reg<regs::HuffencAc161, crate::common::RW> {
2330 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0754usize) as _) }
2331 }
2332 #[doc = "JPEG encoder, AC Huffman table 1"]
2333 #[inline(always)]
2334 pub const fn huffenc_ac1_62(self) -> crate::common::Reg<regs::HuffencAc162, crate::common::RW> {
2335 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0758usize) as _) }
2336 }
2337 #[doc = "JPEG encoder, AC Huffman table 1"]
2338 #[inline(always)]
2339 pub const fn huffenc_ac1_63(self) -> crate::common::Reg<regs::HuffencAc163, crate::common::RW> {
2340 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x075cusize) as _) }
2341 }
2342 #[doc = "JPEG encoder, AC Huffman table 1"]
2343 #[inline(always)]
2344 pub const fn huffenc_ac1_64(self) -> crate::common::Reg<regs::HuffencAc164, crate::common::RW> {
2345 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0760usize) as _) }
2346 }
2347 #[doc = "JPEG encoder, AC Huffman table 1"]
2348 #[inline(always)]
2349 pub const fn huffenc_ac1_65(self) -> crate::common::Reg<regs::HuffencAc165, crate::common::RW> {
2350 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0764usize) as _) }
2351 }
2352 #[doc = "JPEG encoder, AC Huffman table 1"]
2353 #[inline(always)]
2354 pub const fn huffenc_ac1_66(self) -> crate::common::Reg<regs::HuffencAc166, crate::common::RW> {
2355 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0768usize) as _) }
2356 }
2357 #[doc = "JPEG encoder, AC Huffman table 1"]
2358 #[inline(always)]
2359 pub const fn huffenc_ac1_67(self) -> crate::common::Reg<regs::HuffencAc167, crate::common::RW> {
2360 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x076cusize) as _) }
2361 }
2362 #[doc = "JPEG encoder, AC Huffman table 1"]
2363 #[inline(always)]
2364 pub const fn huffenc_ac1_68(self) -> crate::common::Reg<regs::HuffencAc168, crate::common::RW> {
2365 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0770usize) as _) }
2366 }
2367 #[doc = "JPEG encoder, AC Huffman table 1"]
2368 #[inline(always)]
2369 pub const fn huffenc_ac1_69(self) -> crate::common::Reg<regs::HuffencAc169, crate::common::RW> {
2370 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0774usize) as _) }
2371 }
2372 #[doc = "JPEG encoder, AC Huffman table 1"]
2373 #[inline(always)]
2374 pub const fn huffenc_ac1_70(self) -> crate::common::Reg<regs::HuffencAc170, crate::common::RW> {
2375 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0778usize) as _) }
2376 }
2377 #[doc = "JPEG encoder, AC Huffman table 1"]
2378 #[inline(always)]
2379 pub const fn huffenc_ac1_71(self) -> crate::common::Reg<regs::HuffencAc171, crate::common::RW> {
2380 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x077cusize) as _) }
2381 }
2382 #[doc = "JPEG encoder, AC Huffman table 1"]
2383 #[inline(always)]
2384 pub const fn huffenc_ac1_72(self) -> crate::common::Reg<regs::HuffencAc172, crate::common::RW> {
2385 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0780usize) as _) }
2386 }
2387 #[doc = "JPEG encoder, AC Huffman table 1"]
2388 #[inline(always)]
2389 pub const fn huffenc_ac1_73(self) -> crate::common::Reg<regs::HuffencAc173, crate::common::RW> {
2390 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0784usize) as _) }
2391 }
2392 #[doc = "JPEG encoder, AC Huffman table 1"]
2393 #[inline(always)]
2394 pub const fn huffenc_ac1_74(self) -> crate::common::Reg<regs::HuffencAc174, crate::common::RW> {
2395 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0788usize) as _) }
2396 }
2397 #[doc = "JPEG encoder, AC Huffman table 1"]
2398 #[inline(always)]
2399 pub const fn huffenc_ac1_75(self) -> crate::common::Reg<regs::HuffencAc175, crate::common::RW> {
2400 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x078cusize) as _) }
2401 }
2402 #[doc = "JPEG encoder, AC Huffman table 1"]
2403 #[inline(always)]
2404 pub const fn huffenc_ac1_76(self) -> crate::common::Reg<regs::HuffencAc176, crate::common::RW> {
2405 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0790usize) as _) }
2406 }
2407 #[doc = "JPEG encoder, AC Huffman table 1"]
2408 #[inline(always)]
2409 pub const fn huffenc_ac1_77(self) -> crate::common::Reg<regs::HuffencAc177, crate::common::RW> {
2410 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0794usize) as _) }
2411 }
2412 #[doc = "JPEG encoder, AC Huffman table 1"]
2413 #[inline(always)]
2414 pub const fn huffenc_ac1_78(self) -> crate::common::Reg<regs::HuffencAc178, crate::common::RW> {
2415 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0798usize) as _) }
2416 }
2417 #[doc = "JPEG encoder, AC Huffman table 1"]
2418 #[inline(always)]
2419 pub const fn huffenc_ac1_79(self) -> crate::common::Reg<regs::HuffencAc179, crate::common::RW> {
2420 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x079cusize) as _) }
2421 }
2422 #[doc = "JPEG encoder, AC Huffman table 1"]
2423 #[inline(always)]
2424 pub const fn huffenc_ac1_80(self) -> crate::common::Reg<regs::HuffencAc180, crate::common::RW> {
2425 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07a0usize) as _) }
2426 }
2427 #[doc = "JPEG encoder, AC Huffman table 1"]
2428 #[inline(always)]
2429 pub const fn huffenc_ac1_81(self) -> crate::common::Reg<regs::HuffencAc181, crate::common::RW> {
2430 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07a4usize) as _) }
2431 }
2432 #[doc = "JPEG encoder, AC Huffman table 1"]
2433 #[inline(always)]
2434 pub const fn huffenc_ac1_82(self) -> crate::common::Reg<regs::HuffencAc182, crate::common::RW> {
2435 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07a8usize) as _) }
2436 }
2437 #[doc = "JPEG encoder, AC Huffman table 1"]
2438 #[inline(always)]
2439 pub const fn huffenc_ac1_83(self) -> crate::common::Reg<regs::HuffencAc183, crate::common::RW> {
2440 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07acusize) as _) }
2441 }
2442 #[doc = "JPEG encoder, AC Huffman table 1"]
2443 #[inline(always)]
2444 pub const fn huffenc_ac1_84(self) -> crate::common::Reg<regs::HuffencAc184, crate::common::RW> {
2445 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07b0usize) as _) }
2446 }
2447 #[doc = "JPEG encoder, AC Huffman table 1"]
2448 #[inline(always)]
2449 pub const fn huffenc_ac1_85(self) -> crate::common::Reg<regs::HuffencAc185, crate::common::RW> {
2450 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07b4usize) as _) }
2451 }
2452 #[doc = "JPEG encoder, AC Huffman table 1"]
2453 #[inline(always)]
2454 pub const fn huffenc_ac1_86(self) -> crate::common::Reg<regs::HuffencAc186, crate::common::RW> {
2455 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07b8usize) as _) }
2456 }
2457 #[doc = "JPEG encoder, AC Huffman table 1"]
2458 #[inline(always)]
2459 pub const fn huffenc_ac1_87(self) -> crate::common::Reg<regs::HuffencAc187, crate::common::RW> {
2460 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07bcusize) as _) }
2461 }
2462 #[doc = "JPEG encoder, DC Huffman table 0"]
2463 #[inline(always)]
2464 pub const fn huffenc_dc0_0(self) -> crate::common::Reg<regs::HuffencDc00, crate::common::RW> {
2465 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07c0usize) as _) }
2466 }
2467 #[doc = "JPEG encoder, DC Huffman table 0"]
2468 #[inline(always)]
2469 pub const fn huffenc_dc0_1(self) -> crate::common::Reg<regs::HuffencDc01, crate::common::RW> {
2470 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07c4usize) as _) }
2471 }
2472 #[doc = "JPEG encoder, DC Huffman table 0"]
2473 #[inline(always)]
2474 pub const fn huffenc_dc0_2(self) -> crate::common::Reg<regs::HuffencDc02, crate::common::RW> {
2475 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07c8usize) as _) }
2476 }
2477 #[doc = "JPEG encoder, DC Huffman table 0"]
2478 #[inline(always)]
2479 pub const fn huffenc_dc0_3(self) -> crate::common::Reg<regs::HuffencDc03, crate::common::RW> {
2480 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07ccusize) as _) }
2481 }
2482 #[doc = "JPEG encoder, DC Huffman table 0"]
2483 #[inline(always)]
2484 pub const fn huffenc_dc0_4(self) -> crate::common::Reg<regs::HuffencDc04, crate::common::RW> {
2485 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07d0usize) as _) }
2486 }
2487 #[doc = "JPEG encoder, DC Huffman table 0"]
2488 #[inline(always)]
2489 pub const fn huffenc_dc0_5(self) -> crate::common::Reg<regs::HuffencDc05, crate::common::RW> {
2490 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07d4usize) as _) }
2491 }
2492 #[doc = "JPEG encoder, DC Huffman table 0"]
2493 #[inline(always)]
2494 pub const fn huffenc_dc0_6(self) -> crate::common::Reg<regs::HuffencDc06, crate::common::RW> {
2495 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07d8usize) as _) }
2496 }
2497 #[doc = "JPEG encoder, DC Huffman table 0"]
2498 #[inline(always)]
2499 pub const fn huffenc_dc0_7(self) -> crate::common::Reg<regs::HuffencDc07, crate::common::RW> {
2500 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07dcusize) as _) }
2501 }
2502 #[doc = "JPEG encoder, DC Huffman table 1"]
2503 #[inline(always)]
2504 pub const fn huffenc_dc1_0(self) -> crate::common::Reg<regs::HuffencDc10, crate::common::RW> {
2505 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07e0usize) as _) }
2506 }
2507 #[doc = "JPEG encoder, DC Huffman table 1"]
2508 #[inline(always)]
2509 pub const fn huffenc_dc1_1(self) -> crate::common::Reg<regs::HuffencDc11, crate::common::RW> {
2510 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07e4usize) as _) }
2511 }
2512 #[doc = "JPEG encoder, DC Huffman table 1"]
2513 #[inline(always)]
2514 pub const fn huffenc_dc1_2(self) -> crate::common::Reg<regs::HuffencDc12, crate::common::RW> {
2515 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07e8usize) as _) }
2516 }
2517 #[doc = "JPEG encoder, DC Huffman table 1"]
2518 #[inline(always)]
2519 pub const fn huffenc_dc1_3(self) -> crate::common::Reg<regs::HuffencDc13, crate::common::RW> {
2520 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07ecusize) as _) }
2521 }
2522 #[doc = "JPEG encoder, DC Huffman table 1"]
2523 #[inline(always)]
2524 pub const fn huffenc_dc1_4(self) -> crate::common::Reg<regs::HuffencDc14, crate::common::RW> {
2525 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07f0usize) as _) }
2526 }
2527 #[doc = "JPEG encoder, DC Huffman table 1"]
2528 #[inline(always)]
2529 pub const fn huffenc_dc1_5(self) -> crate::common::Reg<regs::HuffencDc15, crate::common::RW> {
2530 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07f4usize) as _) }
2531 }
2532 #[doc = "JPEG encoder, DC Huffman table 1"]
2533 #[inline(always)]
2534 pub const fn huffenc_dc1_6(self) -> crate::common::Reg<regs::HuffencDc16, crate::common::RW> {
2535 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07f8usize) as _) }
2536 }
2537 #[doc = "JPEG encoder, DC Huffman table 1"]
2538 #[inline(always)]
2539 pub const fn huffenc_dc1_7(self) -> crate::common::Reg<regs::HuffencDc17, crate::common::RW> {
2540 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x07fcusize) as _) }
2541 }
2542}
2543pub mod regs {
2544 #[doc = "JPEG DHTMem tables"]
2545 #[repr(transparent)]
2546 #[derive(Copy, Clone, Eq, PartialEq)]
2547 pub struct Dhtmem0(pub u32);
2548 impl Dhtmem0 {
2549 #[doc = "DHTMem RAM"]
2550 #[inline(always)]
2551 pub const fn dhtmem_ram(&self) -> u32 {
2552 let val = (self.0 >> 0usize) & 0xffff_ffff;
2553 val as u32
2554 }
2555 #[doc = "DHTMem RAM"]
2556 #[inline(always)]
2557 pub fn set_dhtmem_ram(&mut self, val: u32) {
2558 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2559 }
2560 }
2561 impl Default for Dhtmem0 {
2562 #[inline(always)]
2563 fn default() -> Dhtmem0 {
2564 Dhtmem0(0)
2565 }
2566 }
2567 impl core::fmt::Debug for Dhtmem0 {
2568 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2569 f.debug_struct("Dhtmem0")
2570 .field("dhtmem_ram", &self.dhtmem_ram())
2571 .finish()
2572 }
2573 }
2574 #[cfg(feature = "defmt")]
2575 impl defmt::Format for Dhtmem0 {
2576 fn format(&self, f: defmt::Formatter) {
2577 #[derive(defmt :: Format)]
2578 struct Dhtmem0 {
2579 dhtmem_ram: u32,
2580 }
2581 let proxy = Dhtmem0 {
2582 dhtmem_ram: self.dhtmem_ram(),
2583 };
2584 defmt::write!(f, "{}", proxy)
2585 }
2586 }
2587 #[doc = "JPEG DHTMem tables"]
2588 #[repr(transparent)]
2589 #[derive(Copy, Clone, Eq, PartialEq)]
2590 pub struct Dhtmem10(pub u32);
2591 impl Dhtmem10 {
2592 #[doc = "DHTMem RAM"]
2593 #[inline(always)]
2594 pub const fn dhtmem_ram(&self) -> u32 {
2595 let val = (self.0 >> 0usize) & 0xffff_ffff;
2596 val as u32
2597 }
2598 #[doc = "DHTMem RAM"]
2599 #[inline(always)]
2600 pub fn set_dhtmem_ram(&mut self, val: u32) {
2601 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2602 }
2603 }
2604 impl Default for Dhtmem10 {
2605 #[inline(always)]
2606 fn default() -> Dhtmem10 {
2607 Dhtmem10(0)
2608 }
2609 }
2610 impl core::fmt::Debug for Dhtmem10 {
2611 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2612 f.debug_struct("Dhtmem10")
2613 .field("dhtmem_ram", &self.dhtmem_ram())
2614 .finish()
2615 }
2616 }
2617 #[cfg(feature = "defmt")]
2618 impl defmt::Format for Dhtmem10 {
2619 fn format(&self, f: defmt::Formatter) {
2620 #[derive(defmt :: Format)]
2621 struct Dhtmem10 {
2622 dhtmem_ram: u32,
2623 }
2624 let proxy = Dhtmem10 {
2625 dhtmem_ram: self.dhtmem_ram(),
2626 };
2627 defmt::write!(f, "{}", proxy)
2628 }
2629 }
2630 #[doc = "JPEG DHTMem tables"]
2631 #[repr(transparent)]
2632 #[derive(Copy, Clone, Eq, PartialEq)]
2633 pub struct Dhtmem100(pub u32);
2634 impl Dhtmem100 {
2635 #[doc = "DHTMem RAM"]
2636 #[inline(always)]
2637 pub const fn dhtmem_ram(&self) -> u32 {
2638 let val = (self.0 >> 0usize) & 0xffff_ffff;
2639 val as u32
2640 }
2641 #[doc = "DHTMem RAM"]
2642 #[inline(always)]
2643 pub fn set_dhtmem_ram(&mut self, val: u32) {
2644 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2645 }
2646 }
2647 impl Default for Dhtmem100 {
2648 #[inline(always)]
2649 fn default() -> Dhtmem100 {
2650 Dhtmem100(0)
2651 }
2652 }
2653 impl core::fmt::Debug for Dhtmem100 {
2654 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2655 f.debug_struct("Dhtmem100")
2656 .field("dhtmem_ram", &self.dhtmem_ram())
2657 .finish()
2658 }
2659 }
2660 #[cfg(feature = "defmt")]
2661 impl defmt::Format for Dhtmem100 {
2662 fn format(&self, f: defmt::Formatter) {
2663 #[derive(defmt :: Format)]
2664 struct Dhtmem100 {
2665 dhtmem_ram: u32,
2666 }
2667 let proxy = Dhtmem100 {
2668 dhtmem_ram: self.dhtmem_ram(),
2669 };
2670 defmt::write!(f, "{}", proxy)
2671 }
2672 }
2673 #[doc = "JPEG DHTMem tables"]
2674 #[repr(transparent)]
2675 #[derive(Copy, Clone, Eq, PartialEq)]
2676 pub struct Dhtmem101(pub u32);
2677 impl Dhtmem101 {
2678 #[doc = "DHTMem RAM"]
2679 #[inline(always)]
2680 pub const fn dhtmem_ram(&self) -> u32 {
2681 let val = (self.0 >> 0usize) & 0xffff_ffff;
2682 val as u32
2683 }
2684 #[doc = "DHTMem RAM"]
2685 #[inline(always)]
2686 pub fn set_dhtmem_ram(&mut self, val: u32) {
2687 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2688 }
2689 }
2690 impl Default for Dhtmem101 {
2691 #[inline(always)]
2692 fn default() -> Dhtmem101 {
2693 Dhtmem101(0)
2694 }
2695 }
2696 impl core::fmt::Debug for Dhtmem101 {
2697 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2698 f.debug_struct("Dhtmem101")
2699 .field("dhtmem_ram", &self.dhtmem_ram())
2700 .finish()
2701 }
2702 }
2703 #[cfg(feature = "defmt")]
2704 impl defmt::Format for Dhtmem101 {
2705 fn format(&self, f: defmt::Formatter) {
2706 #[derive(defmt :: Format)]
2707 struct Dhtmem101 {
2708 dhtmem_ram: u32,
2709 }
2710 let proxy = Dhtmem101 {
2711 dhtmem_ram: self.dhtmem_ram(),
2712 };
2713 defmt::write!(f, "{}", proxy)
2714 }
2715 }
2716 #[doc = "JPEG DHTMem tables"]
2717 #[repr(transparent)]
2718 #[derive(Copy, Clone, Eq, PartialEq)]
2719 pub struct Dhtmem102(pub u32);
2720 impl Dhtmem102 {
2721 #[doc = "DHTMem RAM"]
2722 #[inline(always)]
2723 pub const fn dhtmem_ram(&self) -> u32 {
2724 let val = (self.0 >> 0usize) & 0xffff_ffff;
2725 val as u32
2726 }
2727 #[doc = "DHTMem RAM"]
2728 #[inline(always)]
2729 pub fn set_dhtmem_ram(&mut self, val: u32) {
2730 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2731 }
2732 }
2733 impl Default for Dhtmem102 {
2734 #[inline(always)]
2735 fn default() -> Dhtmem102 {
2736 Dhtmem102(0)
2737 }
2738 }
2739 impl core::fmt::Debug for Dhtmem102 {
2740 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2741 f.debug_struct("Dhtmem102")
2742 .field("dhtmem_ram", &self.dhtmem_ram())
2743 .finish()
2744 }
2745 }
2746 #[cfg(feature = "defmt")]
2747 impl defmt::Format for Dhtmem102 {
2748 fn format(&self, f: defmt::Formatter) {
2749 #[derive(defmt :: Format)]
2750 struct Dhtmem102 {
2751 dhtmem_ram: u32,
2752 }
2753 let proxy = Dhtmem102 {
2754 dhtmem_ram: self.dhtmem_ram(),
2755 };
2756 defmt::write!(f, "{}", proxy)
2757 }
2758 }
2759 #[doc = "JPEG DHTMem tables"]
2760 #[repr(transparent)]
2761 #[derive(Copy, Clone, Eq, PartialEq)]
2762 pub struct Dhtmem103(pub u32);
2763 impl Dhtmem103 {
2764 #[doc = "DHTMem RAM"]
2765 #[inline(always)]
2766 pub const fn dhtmem_ram(&self) -> u32 {
2767 let val = (self.0 >> 0usize) & 0xffff_ffff;
2768 val as u32
2769 }
2770 #[doc = "DHTMem RAM"]
2771 #[inline(always)]
2772 pub fn set_dhtmem_ram(&mut self, val: u32) {
2773 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2774 }
2775 }
2776 impl Default for Dhtmem103 {
2777 #[inline(always)]
2778 fn default() -> Dhtmem103 {
2779 Dhtmem103(0)
2780 }
2781 }
2782 impl core::fmt::Debug for Dhtmem103 {
2783 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2784 f.debug_struct("Dhtmem103")
2785 .field("dhtmem_ram", &self.dhtmem_ram())
2786 .finish()
2787 }
2788 }
2789 #[cfg(feature = "defmt")]
2790 impl defmt::Format for Dhtmem103 {
2791 fn format(&self, f: defmt::Formatter) {
2792 #[derive(defmt :: Format)]
2793 struct Dhtmem103 {
2794 dhtmem_ram: u32,
2795 }
2796 let proxy = Dhtmem103 {
2797 dhtmem_ram: self.dhtmem_ram(),
2798 };
2799 defmt::write!(f, "{}", proxy)
2800 }
2801 }
2802 #[doc = "JPEG DHTMem tables"]
2803 #[repr(transparent)]
2804 #[derive(Copy, Clone, Eq, PartialEq)]
2805 pub struct Dhtmem11(pub u32);
2806 impl Dhtmem11 {
2807 #[doc = "DHTMem RAM"]
2808 #[inline(always)]
2809 pub const fn dhtmem_ram(&self) -> u32 {
2810 let val = (self.0 >> 0usize) & 0xffff_ffff;
2811 val as u32
2812 }
2813 #[doc = "DHTMem RAM"]
2814 #[inline(always)]
2815 pub fn set_dhtmem_ram(&mut self, val: u32) {
2816 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2817 }
2818 }
2819 impl Default for Dhtmem11 {
2820 #[inline(always)]
2821 fn default() -> Dhtmem11 {
2822 Dhtmem11(0)
2823 }
2824 }
2825 impl core::fmt::Debug for Dhtmem11 {
2826 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2827 f.debug_struct("Dhtmem11")
2828 .field("dhtmem_ram", &self.dhtmem_ram())
2829 .finish()
2830 }
2831 }
2832 #[cfg(feature = "defmt")]
2833 impl defmt::Format for Dhtmem11 {
2834 fn format(&self, f: defmt::Formatter) {
2835 #[derive(defmt :: Format)]
2836 struct Dhtmem11 {
2837 dhtmem_ram: u32,
2838 }
2839 let proxy = Dhtmem11 {
2840 dhtmem_ram: self.dhtmem_ram(),
2841 };
2842 defmt::write!(f, "{}", proxy)
2843 }
2844 }
2845 #[doc = "JPEG DHTMem tables"]
2846 #[repr(transparent)]
2847 #[derive(Copy, Clone, Eq, PartialEq)]
2848 pub struct Dhtmem12(pub u32);
2849 impl Dhtmem12 {
2850 #[doc = "DHTMem RAM"]
2851 #[inline(always)]
2852 pub const fn dhtmem_ram(&self) -> u32 {
2853 let val = (self.0 >> 0usize) & 0xffff_ffff;
2854 val as u32
2855 }
2856 #[doc = "DHTMem RAM"]
2857 #[inline(always)]
2858 pub fn set_dhtmem_ram(&mut self, val: u32) {
2859 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2860 }
2861 }
2862 impl Default for Dhtmem12 {
2863 #[inline(always)]
2864 fn default() -> Dhtmem12 {
2865 Dhtmem12(0)
2866 }
2867 }
2868 impl core::fmt::Debug for Dhtmem12 {
2869 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2870 f.debug_struct("Dhtmem12")
2871 .field("dhtmem_ram", &self.dhtmem_ram())
2872 .finish()
2873 }
2874 }
2875 #[cfg(feature = "defmt")]
2876 impl defmt::Format for Dhtmem12 {
2877 fn format(&self, f: defmt::Formatter) {
2878 #[derive(defmt :: Format)]
2879 struct Dhtmem12 {
2880 dhtmem_ram: u32,
2881 }
2882 let proxy = Dhtmem12 {
2883 dhtmem_ram: self.dhtmem_ram(),
2884 };
2885 defmt::write!(f, "{}", proxy)
2886 }
2887 }
2888 #[doc = "JPEG DHTMem tables"]
2889 #[repr(transparent)]
2890 #[derive(Copy, Clone, Eq, PartialEq)]
2891 pub struct Dhtmem13(pub u32);
2892 impl Dhtmem13 {
2893 #[doc = "DHTMem RAM"]
2894 #[inline(always)]
2895 pub const fn dhtmem_ram(&self) -> u32 {
2896 let val = (self.0 >> 0usize) & 0xffff_ffff;
2897 val as u32
2898 }
2899 #[doc = "DHTMem RAM"]
2900 #[inline(always)]
2901 pub fn set_dhtmem_ram(&mut self, val: u32) {
2902 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2903 }
2904 }
2905 impl Default for Dhtmem13 {
2906 #[inline(always)]
2907 fn default() -> Dhtmem13 {
2908 Dhtmem13(0)
2909 }
2910 }
2911 impl core::fmt::Debug for Dhtmem13 {
2912 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2913 f.debug_struct("Dhtmem13")
2914 .field("dhtmem_ram", &self.dhtmem_ram())
2915 .finish()
2916 }
2917 }
2918 #[cfg(feature = "defmt")]
2919 impl defmt::Format for Dhtmem13 {
2920 fn format(&self, f: defmt::Formatter) {
2921 #[derive(defmt :: Format)]
2922 struct Dhtmem13 {
2923 dhtmem_ram: u32,
2924 }
2925 let proxy = Dhtmem13 {
2926 dhtmem_ram: self.dhtmem_ram(),
2927 };
2928 defmt::write!(f, "{}", proxy)
2929 }
2930 }
2931 #[doc = "JPEG DHTMem tables"]
2932 #[repr(transparent)]
2933 #[derive(Copy, Clone, Eq, PartialEq)]
2934 pub struct Dhtmem14(pub u32);
2935 impl Dhtmem14 {
2936 #[doc = "DHTMem RAM"]
2937 #[inline(always)]
2938 pub const fn dhtmem_ram(&self) -> u32 {
2939 let val = (self.0 >> 0usize) & 0xffff_ffff;
2940 val as u32
2941 }
2942 #[doc = "DHTMem RAM"]
2943 #[inline(always)]
2944 pub fn set_dhtmem_ram(&mut self, val: u32) {
2945 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2946 }
2947 }
2948 impl Default for Dhtmem14 {
2949 #[inline(always)]
2950 fn default() -> Dhtmem14 {
2951 Dhtmem14(0)
2952 }
2953 }
2954 impl core::fmt::Debug for Dhtmem14 {
2955 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2956 f.debug_struct("Dhtmem14")
2957 .field("dhtmem_ram", &self.dhtmem_ram())
2958 .finish()
2959 }
2960 }
2961 #[cfg(feature = "defmt")]
2962 impl defmt::Format for Dhtmem14 {
2963 fn format(&self, f: defmt::Formatter) {
2964 #[derive(defmt :: Format)]
2965 struct Dhtmem14 {
2966 dhtmem_ram: u32,
2967 }
2968 let proxy = Dhtmem14 {
2969 dhtmem_ram: self.dhtmem_ram(),
2970 };
2971 defmt::write!(f, "{}", proxy)
2972 }
2973 }
2974 #[doc = "JPEG DHTMem tables"]
2975 #[repr(transparent)]
2976 #[derive(Copy, Clone, Eq, PartialEq)]
2977 pub struct Dhtmem15(pub u32);
2978 impl Dhtmem15 {
2979 #[doc = "DHTMem RAM"]
2980 #[inline(always)]
2981 pub const fn dhtmem_ram(&self) -> u32 {
2982 let val = (self.0 >> 0usize) & 0xffff_ffff;
2983 val as u32
2984 }
2985 #[doc = "DHTMem RAM"]
2986 #[inline(always)]
2987 pub fn set_dhtmem_ram(&mut self, val: u32) {
2988 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
2989 }
2990 }
2991 impl Default for Dhtmem15 {
2992 #[inline(always)]
2993 fn default() -> Dhtmem15 {
2994 Dhtmem15(0)
2995 }
2996 }
2997 impl core::fmt::Debug for Dhtmem15 {
2998 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2999 f.debug_struct("Dhtmem15")
3000 .field("dhtmem_ram", &self.dhtmem_ram())
3001 .finish()
3002 }
3003 }
3004 #[cfg(feature = "defmt")]
3005 impl defmt::Format for Dhtmem15 {
3006 fn format(&self, f: defmt::Formatter) {
3007 #[derive(defmt :: Format)]
3008 struct Dhtmem15 {
3009 dhtmem_ram: u32,
3010 }
3011 let proxy = Dhtmem15 {
3012 dhtmem_ram: self.dhtmem_ram(),
3013 };
3014 defmt::write!(f, "{}", proxy)
3015 }
3016 }
3017 #[doc = "JPEG DHTMem tables"]
3018 #[repr(transparent)]
3019 #[derive(Copy, Clone, Eq, PartialEq)]
3020 pub struct Dhtmem16(pub u32);
3021 impl Dhtmem16 {
3022 #[doc = "DHTMem RAM"]
3023 #[inline(always)]
3024 pub const fn dhtmem_ram(&self) -> u32 {
3025 let val = (self.0 >> 0usize) & 0xffff_ffff;
3026 val as u32
3027 }
3028 #[doc = "DHTMem RAM"]
3029 #[inline(always)]
3030 pub fn set_dhtmem_ram(&mut self, val: u32) {
3031 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3032 }
3033 }
3034 impl Default for Dhtmem16 {
3035 #[inline(always)]
3036 fn default() -> Dhtmem16 {
3037 Dhtmem16(0)
3038 }
3039 }
3040 impl core::fmt::Debug for Dhtmem16 {
3041 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3042 f.debug_struct("Dhtmem16")
3043 .field("dhtmem_ram", &self.dhtmem_ram())
3044 .finish()
3045 }
3046 }
3047 #[cfg(feature = "defmt")]
3048 impl defmt::Format for Dhtmem16 {
3049 fn format(&self, f: defmt::Formatter) {
3050 #[derive(defmt :: Format)]
3051 struct Dhtmem16 {
3052 dhtmem_ram: u32,
3053 }
3054 let proxy = Dhtmem16 {
3055 dhtmem_ram: self.dhtmem_ram(),
3056 };
3057 defmt::write!(f, "{}", proxy)
3058 }
3059 }
3060 #[doc = "JPEG DHTMem tables"]
3061 #[repr(transparent)]
3062 #[derive(Copy, Clone, Eq, PartialEq)]
3063 pub struct Dhtmem17(pub u32);
3064 impl Dhtmem17 {
3065 #[doc = "DHTMem RAM"]
3066 #[inline(always)]
3067 pub const fn dhtmem_ram(&self) -> u32 {
3068 let val = (self.0 >> 0usize) & 0xffff_ffff;
3069 val as u32
3070 }
3071 #[doc = "DHTMem RAM"]
3072 #[inline(always)]
3073 pub fn set_dhtmem_ram(&mut self, val: u32) {
3074 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3075 }
3076 }
3077 impl Default for Dhtmem17 {
3078 #[inline(always)]
3079 fn default() -> Dhtmem17 {
3080 Dhtmem17(0)
3081 }
3082 }
3083 impl core::fmt::Debug for Dhtmem17 {
3084 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3085 f.debug_struct("Dhtmem17")
3086 .field("dhtmem_ram", &self.dhtmem_ram())
3087 .finish()
3088 }
3089 }
3090 #[cfg(feature = "defmt")]
3091 impl defmt::Format for Dhtmem17 {
3092 fn format(&self, f: defmt::Formatter) {
3093 #[derive(defmt :: Format)]
3094 struct Dhtmem17 {
3095 dhtmem_ram: u32,
3096 }
3097 let proxy = Dhtmem17 {
3098 dhtmem_ram: self.dhtmem_ram(),
3099 };
3100 defmt::write!(f, "{}", proxy)
3101 }
3102 }
3103 #[doc = "JPEG DHTMem tables"]
3104 #[repr(transparent)]
3105 #[derive(Copy, Clone, Eq, PartialEq)]
3106 pub struct Dhtmem18(pub u32);
3107 impl Dhtmem18 {
3108 #[doc = "DHTMem RAM"]
3109 #[inline(always)]
3110 pub const fn dhtmem_ram(&self) -> u32 {
3111 let val = (self.0 >> 0usize) & 0xffff_ffff;
3112 val as u32
3113 }
3114 #[doc = "DHTMem RAM"]
3115 #[inline(always)]
3116 pub fn set_dhtmem_ram(&mut self, val: u32) {
3117 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3118 }
3119 }
3120 impl Default for Dhtmem18 {
3121 #[inline(always)]
3122 fn default() -> Dhtmem18 {
3123 Dhtmem18(0)
3124 }
3125 }
3126 impl core::fmt::Debug for Dhtmem18 {
3127 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3128 f.debug_struct("Dhtmem18")
3129 .field("dhtmem_ram", &self.dhtmem_ram())
3130 .finish()
3131 }
3132 }
3133 #[cfg(feature = "defmt")]
3134 impl defmt::Format for Dhtmem18 {
3135 fn format(&self, f: defmt::Formatter) {
3136 #[derive(defmt :: Format)]
3137 struct Dhtmem18 {
3138 dhtmem_ram: u32,
3139 }
3140 let proxy = Dhtmem18 {
3141 dhtmem_ram: self.dhtmem_ram(),
3142 };
3143 defmt::write!(f, "{}", proxy)
3144 }
3145 }
3146 #[doc = "JPEG DHTMem tables"]
3147 #[repr(transparent)]
3148 #[derive(Copy, Clone, Eq, PartialEq)]
3149 pub struct Dhtmem19(pub u32);
3150 impl Dhtmem19 {
3151 #[doc = "DHTMem RAM"]
3152 #[inline(always)]
3153 pub const fn dhtmem_ram(&self) -> u32 {
3154 let val = (self.0 >> 0usize) & 0xffff_ffff;
3155 val as u32
3156 }
3157 #[doc = "DHTMem RAM"]
3158 #[inline(always)]
3159 pub fn set_dhtmem_ram(&mut self, val: u32) {
3160 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3161 }
3162 }
3163 impl Default for Dhtmem19 {
3164 #[inline(always)]
3165 fn default() -> Dhtmem19 {
3166 Dhtmem19(0)
3167 }
3168 }
3169 impl core::fmt::Debug for Dhtmem19 {
3170 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3171 f.debug_struct("Dhtmem19")
3172 .field("dhtmem_ram", &self.dhtmem_ram())
3173 .finish()
3174 }
3175 }
3176 #[cfg(feature = "defmt")]
3177 impl defmt::Format for Dhtmem19 {
3178 fn format(&self, f: defmt::Formatter) {
3179 #[derive(defmt :: Format)]
3180 struct Dhtmem19 {
3181 dhtmem_ram: u32,
3182 }
3183 let proxy = Dhtmem19 {
3184 dhtmem_ram: self.dhtmem_ram(),
3185 };
3186 defmt::write!(f, "{}", proxy)
3187 }
3188 }
3189 #[doc = "JPEG DHTMem tables"]
3190 #[repr(transparent)]
3191 #[derive(Copy, Clone, Eq, PartialEq)]
3192 pub struct Dhtmem2(pub u32);
3193 impl Dhtmem2 {
3194 #[doc = "DHTMem RAM"]
3195 #[inline(always)]
3196 pub const fn dhtmem_ram(&self) -> u32 {
3197 let val = (self.0 >> 0usize) & 0xffff_ffff;
3198 val as u32
3199 }
3200 #[doc = "DHTMem RAM"]
3201 #[inline(always)]
3202 pub fn set_dhtmem_ram(&mut self, val: u32) {
3203 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3204 }
3205 }
3206 impl Default for Dhtmem2 {
3207 #[inline(always)]
3208 fn default() -> Dhtmem2 {
3209 Dhtmem2(0)
3210 }
3211 }
3212 impl core::fmt::Debug for Dhtmem2 {
3213 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3214 f.debug_struct("Dhtmem2")
3215 .field("dhtmem_ram", &self.dhtmem_ram())
3216 .finish()
3217 }
3218 }
3219 #[cfg(feature = "defmt")]
3220 impl defmt::Format for Dhtmem2 {
3221 fn format(&self, f: defmt::Formatter) {
3222 #[derive(defmt :: Format)]
3223 struct Dhtmem2 {
3224 dhtmem_ram: u32,
3225 }
3226 let proxy = Dhtmem2 {
3227 dhtmem_ram: self.dhtmem_ram(),
3228 };
3229 defmt::write!(f, "{}", proxy)
3230 }
3231 }
3232 #[doc = "JPEG DHTMem tables"]
3233 #[repr(transparent)]
3234 #[derive(Copy, Clone, Eq, PartialEq)]
3235 pub struct Dhtmem20(pub u32);
3236 impl Dhtmem20 {
3237 #[doc = "DHTMem RAM"]
3238 #[inline(always)]
3239 pub const fn dhtmem_ram(&self) -> u32 {
3240 let val = (self.0 >> 0usize) & 0xffff_ffff;
3241 val as u32
3242 }
3243 #[doc = "DHTMem RAM"]
3244 #[inline(always)]
3245 pub fn set_dhtmem_ram(&mut self, val: u32) {
3246 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3247 }
3248 }
3249 impl Default for Dhtmem20 {
3250 #[inline(always)]
3251 fn default() -> Dhtmem20 {
3252 Dhtmem20(0)
3253 }
3254 }
3255 impl core::fmt::Debug for Dhtmem20 {
3256 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3257 f.debug_struct("Dhtmem20")
3258 .field("dhtmem_ram", &self.dhtmem_ram())
3259 .finish()
3260 }
3261 }
3262 #[cfg(feature = "defmt")]
3263 impl defmt::Format for Dhtmem20 {
3264 fn format(&self, f: defmt::Formatter) {
3265 #[derive(defmt :: Format)]
3266 struct Dhtmem20 {
3267 dhtmem_ram: u32,
3268 }
3269 let proxy = Dhtmem20 {
3270 dhtmem_ram: self.dhtmem_ram(),
3271 };
3272 defmt::write!(f, "{}", proxy)
3273 }
3274 }
3275 #[doc = "JPEG DHTMem tables"]
3276 #[repr(transparent)]
3277 #[derive(Copy, Clone, Eq, PartialEq)]
3278 pub struct Dhtmem21(pub u32);
3279 impl Dhtmem21 {
3280 #[doc = "DHTMem RAM"]
3281 #[inline(always)]
3282 pub const fn dhtmem_ram(&self) -> u32 {
3283 let val = (self.0 >> 0usize) & 0xffff_ffff;
3284 val as u32
3285 }
3286 #[doc = "DHTMem RAM"]
3287 #[inline(always)]
3288 pub fn set_dhtmem_ram(&mut self, val: u32) {
3289 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3290 }
3291 }
3292 impl Default for Dhtmem21 {
3293 #[inline(always)]
3294 fn default() -> Dhtmem21 {
3295 Dhtmem21(0)
3296 }
3297 }
3298 impl core::fmt::Debug for Dhtmem21 {
3299 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3300 f.debug_struct("Dhtmem21")
3301 .field("dhtmem_ram", &self.dhtmem_ram())
3302 .finish()
3303 }
3304 }
3305 #[cfg(feature = "defmt")]
3306 impl defmt::Format for Dhtmem21 {
3307 fn format(&self, f: defmt::Formatter) {
3308 #[derive(defmt :: Format)]
3309 struct Dhtmem21 {
3310 dhtmem_ram: u32,
3311 }
3312 let proxy = Dhtmem21 {
3313 dhtmem_ram: self.dhtmem_ram(),
3314 };
3315 defmt::write!(f, "{}", proxy)
3316 }
3317 }
3318 #[doc = "JPEG DHTMem tables"]
3319 #[repr(transparent)]
3320 #[derive(Copy, Clone, Eq, PartialEq)]
3321 pub struct Dhtmem22(pub u32);
3322 impl Dhtmem22 {
3323 #[doc = "DHTMem RAM"]
3324 #[inline(always)]
3325 pub const fn dhtmem_ram(&self) -> u32 {
3326 let val = (self.0 >> 0usize) & 0xffff_ffff;
3327 val as u32
3328 }
3329 #[doc = "DHTMem RAM"]
3330 #[inline(always)]
3331 pub fn set_dhtmem_ram(&mut self, val: u32) {
3332 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3333 }
3334 }
3335 impl Default for Dhtmem22 {
3336 #[inline(always)]
3337 fn default() -> Dhtmem22 {
3338 Dhtmem22(0)
3339 }
3340 }
3341 impl core::fmt::Debug for Dhtmem22 {
3342 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3343 f.debug_struct("Dhtmem22")
3344 .field("dhtmem_ram", &self.dhtmem_ram())
3345 .finish()
3346 }
3347 }
3348 #[cfg(feature = "defmt")]
3349 impl defmt::Format for Dhtmem22 {
3350 fn format(&self, f: defmt::Formatter) {
3351 #[derive(defmt :: Format)]
3352 struct Dhtmem22 {
3353 dhtmem_ram: u32,
3354 }
3355 let proxy = Dhtmem22 {
3356 dhtmem_ram: self.dhtmem_ram(),
3357 };
3358 defmt::write!(f, "{}", proxy)
3359 }
3360 }
3361 #[doc = "JPEG DHTMem tables"]
3362 #[repr(transparent)]
3363 #[derive(Copy, Clone, Eq, PartialEq)]
3364 pub struct Dhtmem23(pub u32);
3365 impl Dhtmem23 {
3366 #[doc = "DHTMem RAM"]
3367 #[inline(always)]
3368 pub const fn dhtmem_ram(&self) -> u32 {
3369 let val = (self.0 >> 0usize) & 0xffff_ffff;
3370 val as u32
3371 }
3372 #[doc = "DHTMem RAM"]
3373 #[inline(always)]
3374 pub fn set_dhtmem_ram(&mut self, val: u32) {
3375 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3376 }
3377 }
3378 impl Default for Dhtmem23 {
3379 #[inline(always)]
3380 fn default() -> Dhtmem23 {
3381 Dhtmem23(0)
3382 }
3383 }
3384 impl core::fmt::Debug for Dhtmem23 {
3385 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3386 f.debug_struct("Dhtmem23")
3387 .field("dhtmem_ram", &self.dhtmem_ram())
3388 .finish()
3389 }
3390 }
3391 #[cfg(feature = "defmt")]
3392 impl defmt::Format for Dhtmem23 {
3393 fn format(&self, f: defmt::Formatter) {
3394 #[derive(defmt :: Format)]
3395 struct Dhtmem23 {
3396 dhtmem_ram: u32,
3397 }
3398 let proxy = Dhtmem23 {
3399 dhtmem_ram: self.dhtmem_ram(),
3400 };
3401 defmt::write!(f, "{}", proxy)
3402 }
3403 }
3404 #[doc = "JPEG DHTMem tables"]
3405 #[repr(transparent)]
3406 #[derive(Copy, Clone, Eq, PartialEq)]
3407 pub struct Dhtmem24(pub u32);
3408 impl Dhtmem24 {
3409 #[doc = "DHTMem RAM"]
3410 #[inline(always)]
3411 pub const fn dhtmem_ram(&self) -> u32 {
3412 let val = (self.0 >> 0usize) & 0xffff_ffff;
3413 val as u32
3414 }
3415 #[doc = "DHTMem RAM"]
3416 #[inline(always)]
3417 pub fn set_dhtmem_ram(&mut self, val: u32) {
3418 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3419 }
3420 }
3421 impl Default for Dhtmem24 {
3422 #[inline(always)]
3423 fn default() -> Dhtmem24 {
3424 Dhtmem24(0)
3425 }
3426 }
3427 impl core::fmt::Debug for Dhtmem24 {
3428 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3429 f.debug_struct("Dhtmem24")
3430 .field("dhtmem_ram", &self.dhtmem_ram())
3431 .finish()
3432 }
3433 }
3434 #[cfg(feature = "defmt")]
3435 impl defmt::Format for Dhtmem24 {
3436 fn format(&self, f: defmt::Formatter) {
3437 #[derive(defmt :: Format)]
3438 struct Dhtmem24 {
3439 dhtmem_ram: u32,
3440 }
3441 let proxy = Dhtmem24 {
3442 dhtmem_ram: self.dhtmem_ram(),
3443 };
3444 defmt::write!(f, "{}", proxy)
3445 }
3446 }
3447 #[doc = "JPEG DHTMem tables"]
3448 #[repr(transparent)]
3449 #[derive(Copy, Clone, Eq, PartialEq)]
3450 pub struct Dhtmem25(pub u32);
3451 impl Dhtmem25 {
3452 #[doc = "DHTMem RAM"]
3453 #[inline(always)]
3454 pub const fn dhtmem_ram(&self) -> u32 {
3455 let val = (self.0 >> 0usize) & 0xffff_ffff;
3456 val as u32
3457 }
3458 #[doc = "DHTMem RAM"]
3459 #[inline(always)]
3460 pub fn set_dhtmem_ram(&mut self, val: u32) {
3461 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3462 }
3463 }
3464 impl Default for Dhtmem25 {
3465 #[inline(always)]
3466 fn default() -> Dhtmem25 {
3467 Dhtmem25(0)
3468 }
3469 }
3470 impl core::fmt::Debug for Dhtmem25 {
3471 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3472 f.debug_struct("Dhtmem25")
3473 .field("dhtmem_ram", &self.dhtmem_ram())
3474 .finish()
3475 }
3476 }
3477 #[cfg(feature = "defmt")]
3478 impl defmt::Format for Dhtmem25 {
3479 fn format(&self, f: defmt::Formatter) {
3480 #[derive(defmt :: Format)]
3481 struct Dhtmem25 {
3482 dhtmem_ram: u32,
3483 }
3484 let proxy = Dhtmem25 {
3485 dhtmem_ram: self.dhtmem_ram(),
3486 };
3487 defmt::write!(f, "{}", proxy)
3488 }
3489 }
3490 #[doc = "JPEG DHTMem tables"]
3491 #[repr(transparent)]
3492 #[derive(Copy, Clone, Eq, PartialEq)]
3493 pub struct Dhtmem26(pub u32);
3494 impl Dhtmem26 {
3495 #[doc = "DHTMem RAM"]
3496 #[inline(always)]
3497 pub const fn dhtmem_ram(&self) -> u32 {
3498 let val = (self.0 >> 0usize) & 0xffff_ffff;
3499 val as u32
3500 }
3501 #[doc = "DHTMem RAM"]
3502 #[inline(always)]
3503 pub fn set_dhtmem_ram(&mut self, val: u32) {
3504 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3505 }
3506 }
3507 impl Default for Dhtmem26 {
3508 #[inline(always)]
3509 fn default() -> Dhtmem26 {
3510 Dhtmem26(0)
3511 }
3512 }
3513 impl core::fmt::Debug for Dhtmem26 {
3514 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3515 f.debug_struct("Dhtmem26")
3516 .field("dhtmem_ram", &self.dhtmem_ram())
3517 .finish()
3518 }
3519 }
3520 #[cfg(feature = "defmt")]
3521 impl defmt::Format for Dhtmem26 {
3522 fn format(&self, f: defmt::Formatter) {
3523 #[derive(defmt :: Format)]
3524 struct Dhtmem26 {
3525 dhtmem_ram: u32,
3526 }
3527 let proxy = Dhtmem26 {
3528 dhtmem_ram: self.dhtmem_ram(),
3529 };
3530 defmt::write!(f, "{}", proxy)
3531 }
3532 }
3533 #[doc = "JPEG DHTMem tables"]
3534 #[repr(transparent)]
3535 #[derive(Copy, Clone, Eq, PartialEq)]
3536 pub struct Dhtmem27(pub u32);
3537 impl Dhtmem27 {
3538 #[doc = "DHTMem RAM"]
3539 #[inline(always)]
3540 pub const fn dhtmem_ram(&self) -> u32 {
3541 let val = (self.0 >> 0usize) & 0xffff_ffff;
3542 val as u32
3543 }
3544 #[doc = "DHTMem RAM"]
3545 #[inline(always)]
3546 pub fn set_dhtmem_ram(&mut self, val: u32) {
3547 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3548 }
3549 }
3550 impl Default for Dhtmem27 {
3551 #[inline(always)]
3552 fn default() -> Dhtmem27 {
3553 Dhtmem27(0)
3554 }
3555 }
3556 impl core::fmt::Debug for Dhtmem27 {
3557 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3558 f.debug_struct("Dhtmem27")
3559 .field("dhtmem_ram", &self.dhtmem_ram())
3560 .finish()
3561 }
3562 }
3563 #[cfg(feature = "defmt")]
3564 impl defmt::Format for Dhtmem27 {
3565 fn format(&self, f: defmt::Formatter) {
3566 #[derive(defmt :: Format)]
3567 struct Dhtmem27 {
3568 dhtmem_ram: u32,
3569 }
3570 let proxy = Dhtmem27 {
3571 dhtmem_ram: self.dhtmem_ram(),
3572 };
3573 defmt::write!(f, "{}", proxy)
3574 }
3575 }
3576 #[doc = "JPEG DHTMem tables"]
3577 #[repr(transparent)]
3578 #[derive(Copy, Clone, Eq, PartialEq)]
3579 pub struct Dhtmem28(pub u32);
3580 impl Dhtmem28 {
3581 #[doc = "DHTMem RAM"]
3582 #[inline(always)]
3583 pub const fn dhtmem_ram(&self) -> u32 {
3584 let val = (self.0 >> 0usize) & 0xffff_ffff;
3585 val as u32
3586 }
3587 #[doc = "DHTMem RAM"]
3588 #[inline(always)]
3589 pub fn set_dhtmem_ram(&mut self, val: u32) {
3590 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3591 }
3592 }
3593 impl Default for Dhtmem28 {
3594 #[inline(always)]
3595 fn default() -> Dhtmem28 {
3596 Dhtmem28(0)
3597 }
3598 }
3599 impl core::fmt::Debug for Dhtmem28 {
3600 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3601 f.debug_struct("Dhtmem28")
3602 .field("dhtmem_ram", &self.dhtmem_ram())
3603 .finish()
3604 }
3605 }
3606 #[cfg(feature = "defmt")]
3607 impl defmt::Format for Dhtmem28 {
3608 fn format(&self, f: defmt::Formatter) {
3609 #[derive(defmt :: Format)]
3610 struct Dhtmem28 {
3611 dhtmem_ram: u32,
3612 }
3613 let proxy = Dhtmem28 {
3614 dhtmem_ram: self.dhtmem_ram(),
3615 };
3616 defmt::write!(f, "{}", proxy)
3617 }
3618 }
3619 #[doc = "JPEG DHTMem tables"]
3620 #[repr(transparent)]
3621 #[derive(Copy, Clone, Eq, PartialEq)]
3622 pub struct Dhtmem29(pub u32);
3623 impl Dhtmem29 {
3624 #[doc = "DHTMem RAM"]
3625 #[inline(always)]
3626 pub const fn dhtmem_ram(&self) -> u32 {
3627 let val = (self.0 >> 0usize) & 0xffff_ffff;
3628 val as u32
3629 }
3630 #[doc = "DHTMem RAM"]
3631 #[inline(always)]
3632 pub fn set_dhtmem_ram(&mut self, val: u32) {
3633 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3634 }
3635 }
3636 impl Default for Dhtmem29 {
3637 #[inline(always)]
3638 fn default() -> Dhtmem29 {
3639 Dhtmem29(0)
3640 }
3641 }
3642 impl core::fmt::Debug for Dhtmem29 {
3643 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3644 f.debug_struct("Dhtmem29")
3645 .field("dhtmem_ram", &self.dhtmem_ram())
3646 .finish()
3647 }
3648 }
3649 #[cfg(feature = "defmt")]
3650 impl defmt::Format for Dhtmem29 {
3651 fn format(&self, f: defmt::Formatter) {
3652 #[derive(defmt :: Format)]
3653 struct Dhtmem29 {
3654 dhtmem_ram: u32,
3655 }
3656 let proxy = Dhtmem29 {
3657 dhtmem_ram: self.dhtmem_ram(),
3658 };
3659 defmt::write!(f, "{}", proxy)
3660 }
3661 }
3662 #[doc = "JPEG DHTMem tables"]
3663 #[repr(transparent)]
3664 #[derive(Copy, Clone, Eq, PartialEq)]
3665 pub struct Dhtmem3(pub u32);
3666 impl Dhtmem3 {
3667 #[doc = "DHTMem RAM"]
3668 #[inline(always)]
3669 pub const fn dhtmem_ram(&self) -> u32 {
3670 let val = (self.0 >> 0usize) & 0xffff_ffff;
3671 val as u32
3672 }
3673 #[doc = "DHTMem RAM"]
3674 #[inline(always)]
3675 pub fn set_dhtmem_ram(&mut self, val: u32) {
3676 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3677 }
3678 }
3679 impl Default for Dhtmem3 {
3680 #[inline(always)]
3681 fn default() -> Dhtmem3 {
3682 Dhtmem3(0)
3683 }
3684 }
3685 impl core::fmt::Debug for Dhtmem3 {
3686 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3687 f.debug_struct("Dhtmem3")
3688 .field("dhtmem_ram", &self.dhtmem_ram())
3689 .finish()
3690 }
3691 }
3692 #[cfg(feature = "defmt")]
3693 impl defmt::Format for Dhtmem3 {
3694 fn format(&self, f: defmt::Formatter) {
3695 #[derive(defmt :: Format)]
3696 struct Dhtmem3 {
3697 dhtmem_ram: u32,
3698 }
3699 let proxy = Dhtmem3 {
3700 dhtmem_ram: self.dhtmem_ram(),
3701 };
3702 defmt::write!(f, "{}", proxy)
3703 }
3704 }
3705 #[doc = "JPEG DHTMem tables"]
3706 #[repr(transparent)]
3707 #[derive(Copy, Clone, Eq, PartialEq)]
3708 pub struct Dhtmem30(pub u32);
3709 impl Dhtmem30 {
3710 #[doc = "DHTMem RAM"]
3711 #[inline(always)]
3712 pub const fn dhtmem_ram(&self) -> u32 {
3713 let val = (self.0 >> 0usize) & 0xffff_ffff;
3714 val as u32
3715 }
3716 #[doc = "DHTMem RAM"]
3717 #[inline(always)]
3718 pub fn set_dhtmem_ram(&mut self, val: u32) {
3719 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3720 }
3721 }
3722 impl Default for Dhtmem30 {
3723 #[inline(always)]
3724 fn default() -> Dhtmem30 {
3725 Dhtmem30(0)
3726 }
3727 }
3728 impl core::fmt::Debug for Dhtmem30 {
3729 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3730 f.debug_struct("Dhtmem30")
3731 .field("dhtmem_ram", &self.dhtmem_ram())
3732 .finish()
3733 }
3734 }
3735 #[cfg(feature = "defmt")]
3736 impl defmt::Format for Dhtmem30 {
3737 fn format(&self, f: defmt::Formatter) {
3738 #[derive(defmt :: Format)]
3739 struct Dhtmem30 {
3740 dhtmem_ram: u32,
3741 }
3742 let proxy = Dhtmem30 {
3743 dhtmem_ram: self.dhtmem_ram(),
3744 };
3745 defmt::write!(f, "{}", proxy)
3746 }
3747 }
3748 #[doc = "JPEG DHTMem tables"]
3749 #[repr(transparent)]
3750 #[derive(Copy, Clone, Eq, PartialEq)]
3751 pub struct Dhtmem31(pub u32);
3752 impl Dhtmem31 {
3753 #[doc = "DHTMem RAM"]
3754 #[inline(always)]
3755 pub const fn dhtmem_ram(&self) -> u32 {
3756 let val = (self.0 >> 0usize) & 0xffff_ffff;
3757 val as u32
3758 }
3759 #[doc = "DHTMem RAM"]
3760 #[inline(always)]
3761 pub fn set_dhtmem_ram(&mut self, val: u32) {
3762 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3763 }
3764 }
3765 impl Default for Dhtmem31 {
3766 #[inline(always)]
3767 fn default() -> Dhtmem31 {
3768 Dhtmem31(0)
3769 }
3770 }
3771 impl core::fmt::Debug for Dhtmem31 {
3772 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3773 f.debug_struct("Dhtmem31")
3774 .field("dhtmem_ram", &self.dhtmem_ram())
3775 .finish()
3776 }
3777 }
3778 #[cfg(feature = "defmt")]
3779 impl defmt::Format for Dhtmem31 {
3780 fn format(&self, f: defmt::Formatter) {
3781 #[derive(defmt :: Format)]
3782 struct Dhtmem31 {
3783 dhtmem_ram: u32,
3784 }
3785 let proxy = Dhtmem31 {
3786 dhtmem_ram: self.dhtmem_ram(),
3787 };
3788 defmt::write!(f, "{}", proxy)
3789 }
3790 }
3791 #[doc = "JPEG DHTMem tables"]
3792 #[repr(transparent)]
3793 #[derive(Copy, Clone, Eq, PartialEq)]
3794 pub struct Dhtmem32(pub u32);
3795 impl Dhtmem32 {
3796 #[doc = "DHTMem RAM"]
3797 #[inline(always)]
3798 pub const fn dhtmem_ram(&self) -> u32 {
3799 let val = (self.0 >> 0usize) & 0xffff_ffff;
3800 val as u32
3801 }
3802 #[doc = "DHTMem RAM"]
3803 #[inline(always)]
3804 pub fn set_dhtmem_ram(&mut self, val: u32) {
3805 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3806 }
3807 }
3808 impl Default for Dhtmem32 {
3809 #[inline(always)]
3810 fn default() -> Dhtmem32 {
3811 Dhtmem32(0)
3812 }
3813 }
3814 impl core::fmt::Debug for Dhtmem32 {
3815 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3816 f.debug_struct("Dhtmem32")
3817 .field("dhtmem_ram", &self.dhtmem_ram())
3818 .finish()
3819 }
3820 }
3821 #[cfg(feature = "defmt")]
3822 impl defmt::Format for Dhtmem32 {
3823 fn format(&self, f: defmt::Formatter) {
3824 #[derive(defmt :: Format)]
3825 struct Dhtmem32 {
3826 dhtmem_ram: u32,
3827 }
3828 let proxy = Dhtmem32 {
3829 dhtmem_ram: self.dhtmem_ram(),
3830 };
3831 defmt::write!(f, "{}", proxy)
3832 }
3833 }
3834 #[doc = "JPEG DHTMem tables"]
3835 #[repr(transparent)]
3836 #[derive(Copy, Clone, Eq, PartialEq)]
3837 pub struct Dhtmem33(pub u32);
3838 impl Dhtmem33 {
3839 #[doc = "DHTMem RAM"]
3840 #[inline(always)]
3841 pub const fn dhtmem_ram(&self) -> u32 {
3842 let val = (self.0 >> 0usize) & 0xffff_ffff;
3843 val as u32
3844 }
3845 #[doc = "DHTMem RAM"]
3846 #[inline(always)]
3847 pub fn set_dhtmem_ram(&mut self, val: u32) {
3848 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3849 }
3850 }
3851 impl Default for Dhtmem33 {
3852 #[inline(always)]
3853 fn default() -> Dhtmem33 {
3854 Dhtmem33(0)
3855 }
3856 }
3857 impl core::fmt::Debug for Dhtmem33 {
3858 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3859 f.debug_struct("Dhtmem33")
3860 .field("dhtmem_ram", &self.dhtmem_ram())
3861 .finish()
3862 }
3863 }
3864 #[cfg(feature = "defmt")]
3865 impl defmt::Format for Dhtmem33 {
3866 fn format(&self, f: defmt::Formatter) {
3867 #[derive(defmt :: Format)]
3868 struct Dhtmem33 {
3869 dhtmem_ram: u32,
3870 }
3871 let proxy = Dhtmem33 {
3872 dhtmem_ram: self.dhtmem_ram(),
3873 };
3874 defmt::write!(f, "{}", proxy)
3875 }
3876 }
3877 #[doc = "JPEG DHTMem tables"]
3878 #[repr(transparent)]
3879 #[derive(Copy, Clone, Eq, PartialEq)]
3880 pub struct Dhtmem34(pub u32);
3881 impl Dhtmem34 {
3882 #[doc = "DHTMem RAM"]
3883 #[inline(always)]
3884 pub const fn dhtmem_ram(&self) -> u32 {
3885 let val = (self.0 >> 0usize) & 0xffff_ffff;
3886 val as u32
3887 }
3888 #[doc = "DHTMem RAM"]
3889 #[inline(always)]
3890 pub fn set_dhtmem_ram(&mut self, val: u32) {
3891 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3892 }
3893 }
3894 impl Default for Dhtmem34 {
3895 #[inline(always)]
3896 fn default() -> Dhtmem34 {
3897 Dhtmem34(0)
3898 }
3899 }
3900 impl core::fmt::Debug for Dhtmem34 {
3901 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3902 f.debug_struct("Dhtmem34")
3903 .field("dhtmem_ram", &self.dhtmem_ram())
3904 .finish()
3905 }
3906 }
3907 #[cfg(feature = "defmt")]
3908 impl defmt::Format for Dhtmem34 {
3909 fn format(&self, f: defmt::Formatter) {
3910 #[derive(defmt :: Format)]
3911 struct Dhtmem34 {
3912 dhtmem_ram: u32,
3913 }
3914 let proxy = Dhtmem34 {
3915 dhtmem_ram: self.dhtmem_ram(),
3916 };
3917 defmt::write!(f, "{}", proxy)
3918 }
3919 }
3920 #[doc = "JPEG DHTMem tables"]
3921 #[repr(transparent)]
3922 #[derive(Copy, Clone, Eq, PartialEq)]
3923 pub struct Dhtmem35(pub u32);
3924 impl Dhtmem35 {
3925 #[doc = "DHTMem RAM"]
3926 #[inline(always)]
3927 pub const fn dhtmem_ram(&self) -> u32 {
3928 let val = (self.0 >> 0usize) & 0xffff_ffff;
3929 val as u32
3930 }
3931 #[doc = "DHTMem RAM"]
3932 #[inline(always)]
3933 pub fn set_dhtmem_ram(&mut self, val: u32) {
3934 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3935 }
3936 }
3937 impl Default for Dhtmem35 {
3938 #[inline(always)]
3939 fn default() -> Dhtmem35 {
3940 Dhtmem35(0)
3941 }
3942 }
3943 impl core::fmt::Debug for Dhtmem35 {
3944 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3945 f.debug_struct("Dhtmem35")
3946 .field("dhtmem_ram", &self.dhtmem_ram())
3947 .finish()
3948 }
3949 }
3950 #[cfg(feature = "defmt")]
3951 impl defmt::Format for Dhtmem35 {
3952 fn format(&self, f: defmt::Formatter) {
3953 #[derive(defmt :: Format)]
3954 struct Dhtmem35 {
3955 dhtmem_ram: u32,
3956 }
3957 let proxy = Dhtmem35 {
3958 dhtmem_ram: self.dhtmem_ram(),
3959 };
3960 defmt::write!(f, "{}", proxy)
3961 }
3962 }
3963 #[doc = "JPEG DHTMem tables"]
3964 #[repr(transparent)]
3965 #[derive(Copy, Clone, Eq, PartialEq)]
3966 pub struct Dhtmem36(pub u32);
3967 impl Dhtmem36 {
3968 #[doc = "DHTMem RAM"]
3969 #[inline(always)]
3970 pub const fn dhtmem_ram(&self) -> u32 {
3971 let val = (self.0 >> 0usize) & 0xffff_ffff;
3972 val as u32
3973 }
3974 #[doc = "DHTMem RAM"]
3975 #[inline(always)]
3976 pub fn set_dhtmem_ram(&mut self, val: u32) {
3977 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
3978 }
3979 }
3980 impl Default for Dhtmem36 {
3981 #[inline(always)]
3982 fn default() -> Dhtmem36 {
3983 Dhtmem36(0)
3984 }
3985 }
3986 impl core::fmt::Debug for Dhtmem36 {
3987 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
3988 f.debug_struct("Dhtmem36")
3989 .field("dhtmem_ram", &self.dhtmem_ram())
3990 .finish()
3991 }
3992 }
3993 #[cfg(feature = "defmt")]
3994 impl defmt::Format for Dhtmem36 {
3995 fn format(&self, f: defmt::Formatter) {
3996 #[derive(defmt :: Format)]
3997 struct Dhtmem36 {
3998 dhtmem_ram: u32,
3999 }
4000 let proxy = Dhtmem36 {
4001 dhtmem_ram: self.dhtmem_ram(),
4002 };
4003 defmt::write!(f, "{}", proxy)
4004 }
4005 }
4006 #[doc = "JPEG DHTMem tables"]
4007 #[repr(transparent)]
4008 #[derive(Copy, Clone, Eq, PartialEq)]
4009 pub struct Dhtmem37(pub u32);
4010 impl Dhtmem37 {
4011 #[doc = "DHTMem RAM"]
4012 #[inline(always)]
4013 pub const fn dhtmem_ram(&self) -> u32 {
4014 let val = (self.0 >> 0usize) & 0xffff_ffff;
4015 val as u32
4016 }
4017 #[doc = "DHTMem RAM"]
4018 #[inline(always)]
4019 pub fn set_dhtmem_ram(&mut self, val: u32) {
4020 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4021 }
4022 }
4023 impl Default for Dhtmem37 {
4024 #[inline(always)]
4025 fn default() -> Dhtmem37 {
4026 Dhtmem37(0)
4027 }
4028 }
4029 impl core::fmt::Debug for Dhtmem37 {
4030 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4031 f.debug_struct("Dhtmem37")
4032 .field("dhtmem_ram", &self.dhtmem_ram())
4033 .finish()
4034 }
4035 }
4036 #[cfg(feature = "defmt")]
4037 impl defmt::Format for Dhtmem37 {
4038 fn format(&self, f: defmt::Formatter) {
4039 #[derive(defmt :: Format)]
4040 struct Dhtmem37 {
4041 dhtmem_ram: u32,
4042 }
4043 let proxy = Dhtmem37 {
4044 dhtmem_ram: self.dhtmem_ram(),
4045 };
4046 defmt::write!(f, "{}", proxy)
4047 }
4048 }
4049 #[doc = "JPEG DHTMem tables"]
4050 #[repr(transparent)]
4051 #[derive(Copy, Clone, Eq, PartialEq)]
4052 pub struct Dhtmem38(pub u32);
4053 impl Dhtmem38 {
4054 #[doc = "DHTMem RAM"]
4055 #[inline(always)]
4056 pub const fn dhtmem_ram(&self) -> u32 {
4057 let val = (self.0 >> 0usize) & 0xffff_ffff;
4058 val as u32
4059 }
4060 #[doc = "DHTMem RAM"]
4061 #[inline(always)]
4062 pub fn set_dhtmem_ram(&mut self, val: u32) {
4063 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4064 }
4065 }
4066 impl Default for Dhtmem38 {
4067 #[inline(always)]
4068 fn default() -> Dhtmem38 {
4069 Dhtmem38(0)
4070 }
4071 }
4072 impl core::fmt::Debug for Dhtmem38 {
4073 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4074 f.debug_struct("Dhtmem38")
4075 .field("dhtmem_ram", &self.dhtmem_ram())
4076 .finish()
4077 }
4078 }
4079 #[cfg(feature = "defmt")]
4080 impl defmt::Format for Dhtmem38 {
4081 fn format(&self, f: defmt::Formatter) {
4082 #[derive(defmt :: Format)]
4083 struct Dhtmem38 {
4084 dhtmem_ram: u32,
4085 }
4086 let proxy = Dhtmem38 {
4087 dhtmem_ram: self.dhtmem_ram(),
4088 };
4089 defmt::write!(f, "{}", proxy)
4090 }
4091 }
4092 #[doc = "JPEG DHTMem tables"]
4093 #[repr(transparent)]
4094 #[derive(Copy, Clone, Eq, PartialEq)]
4095 pub struct Dhtmem39(pub u32);
4096 impl Dhtmem39 {
4097 #[doc = "DHTMem RAM"]
4098 #[inline(always)]
4099 pub const fn dhtmem_ram(&self) -> u32 {
4100 let val = (self.0 >> 0usize) & 0xffff_ffff;
4101 val as u32
4102 }
4103 #[doc = "DHTMem RAM"]
4104 #[inline(always)]
4105 pub fn set_dhtmem_ram(&mut self, val: u32) {
4106 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4107 }
4108 }
4109 impl Default for Dhtmem39 {
4110 #[inline(always)]
4111 fn default() -> Dhtmem39 {
4112 Dhtmem39(0)
4113 }
4114 }
4115 impl core::fmt::Debug for Dhtmem39 {
4116 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4117 f.debug_struct("Dhtmem39")
4118 .field("dhtmem_ram", &self.dhtmem_ram())
4119 .finish()
4120 }
4121 }
4122 #[cfg(feature = "defmt")]
4123 impl defmt::Format for Dhtmem39 {
4124 fn format(&self, f: defmt::Formatter) {
4125 #[derive(defmt :: Format)]
4126 struct Dhtmem39 {
4127 dhtmem_ram: u32,
4128 }
4129 let proxy = Dhtmem39 {
4130 dhtmem_ram: self.dhtmem_ram(),
4131 };
4132 defmt::write!(f, "{}", proxy)
4133 }
4134 }
4135 #[doc = "JPEG DHTMem tables"]
4136 #[repr(transparent)]
4137 #[derive(Copy, Clone, Eq, PartialEq)]
4138 pub struct Dhtmem4(pub u32);
4139 impl Dhtmem4 {
4140 #[doc = "DHTMem RAM"]
4141 #[inline(always)]
4142 pub const fn dhtmem_ram(&self) -> u32 {
4143 let val = (self.0 >> 0usize) & 0xffff_ffff;
4144 val as u32
4145 }
4146 #[doc = "DHTMem RAM"]
4147 #[inline(always)]
4148 pub fn set_dhtmem_ram(&mut self, val: u32) {
4149 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4150 }
4151 }
4152 impl Default for Dhtmem4 {
4153 #[inline(always)]
4154 fn default() -> Dhtmem4 {
4155 Dhtmem4(0)
4156 }
4157 }
4158 impl core::fmt::Debug for Dhtmem4 {
4159 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4160 f.debug_struct("Dhtmem4")
4161 .field("dhtmem_ram", &self.dhtmem_ram())
4162 .finish()
4163 }
4164 }
4165 #[cfg(feature = "defmt")]
4166 impl defmt::Format for Dhtmem4 {
4167 fn format(&self, f: defmt::Formatter) {
4168 #[derive(defmt :: Format)]
4169 struct Dhtmem4 {
4170 dhtmem_ram: u32,
4171 }
4172 let proxy = Dhtmem4 {
4173 dhtmem_ram: self.dhtmem_ram(),
4174 };
4175 defmt::write!(f, "{}", proxy)
4176 }
4177 }
4178 #[doc = "JPEG DHTMem tables"]
4179 #[repr(transparent)]
4180 #[derive(Copy, Clone, Eq, PartialEq)]
4181 pub struct Dhtmem40(pub u32);
4182 impl Dhtmem40 {
4183 #[doc = "DHTMem RAM"]
4184 #[inline(always)]
4185 pub const fn dhtmem_ram(&self) -> u32 {
4186 let val = (self.0 >> 0usize) & 0xffff_ffff;
4187 val as u32
4188 }
4189 #[doc = "DHTMem RAM"]
4190 #[inline(always)]
4191 pub fn set_dhtmem_ram(&mut self, val: u32) {
4192 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4193 }
4194 }
4195 impl Default for Dhtmem40 {
4196 #[inline(always)]
4197 fn default() -> Dhtmem40 {
4198 Dhtmem40(0)
4199 }
4200 }
4201 impl core::fmt::Debug for Dhtmem40 {
4202 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4203 f.debug_struct("Dhtmem40")
4204 .field("dhtmem_ram", &self.dhtmem_ram())
4205 .finish()
4206 }
4207 }
4208 #[cfg(feature = "defmt")]
4209 impl defmt::Format for Dhtmem40 {
4210 fn format(&self, f: defmt::Formatter) {
4211 #[derive(defmt :: Format)]
4212 struct Dhtmem40 {
4213 dhtmem_ram: u32,
4214 }
4215 let proxy = Dhtmem40 {
4216 dhtmem_ram: self.dhtmem_ram(),
4217 };
4218 defmt::write!(f, "{}", proxy)
4219 }
4220 }
4221 #[doc = "JPEG DHTMem tables"]
4222 #[repr(transparent)]
4223 #[derive(Copy, Clone, Eq, PartialEq)]
4224 pub struct Dhtmem41(pub u32);
4225 impl Dhtmem41 {
4226 #[doc = "DHTMem RAM"]
4227 #[inline(always)]
4228 pub const fn dhtmem_ram(&self) -> u32 {
4229 let val = (self.0 >> 0usize) & 0xffff_ffff;
4230 val as u32
4231 }
4232 #[doc = "DHTMem RAM"]
4233 #[inline(always)]
4234 pub fn set_dhtmem_ram(&mut self, val: u32) {
4235 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4236 }
4237 }
4238 impl Default for Dhtmem41 {
4239 #[inline(always)]
4240 fn default() -> Dhtmem41 {
4241 Dhtmem41(0)
4242 }
4243 }
4244 impl core::fmt::Debug for Dhtmem41 {
4245 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4246 f.debug_struct("Dhtmem41")
4247 .field("dhtmem_ram", &self.dhtmem_ram())
4248 .finish()
4249 }
4250 }
4251 #[cfg(feature = "defmt")]
4252 impl defmt::Format for Dhtmem41 {
4253 fn format(&self, f: defmt::Formatter) {
4254 #[derive(defmt :: Format)]
4255 struct Dhtmem41 {
4256 dhtmem_ram: u32,
4257 }
4258 let proxy = Dhtmem41 {
4259 dhtmem_ram: self.dhtmem_ram(),
4260 };
4261 defmt::write!(f, "{}", proxy)
4262 }
4263 }
4264 #[doc = "JPEG DHTMem tables"]
4265 #[repr(transparent)]
4266 #[derive(Copy, Clone, Eq, PartialEq)]
4267 pub struct Dhtmem42(pub u32);
4268 impl Dhtmem42 {
4269 #[doc = "DHTMem RAM"]
4270 #[inline(always)]
4271 pub const fn dhtmem_ram(&self) -> u32 {
4272 let val = (self.0 >> 0usize) & 0xffff_ffff;
4273 val as u32
4274 }
4275 #[doc = "DHTMem RAM"]
4276 #[inline(always)]
4277 pub fn set_dhtmem_ram(&mut self, val: u32) {
4278 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4279 }
4280 }
4281 impl Default for Dhtmem42 {
4282 #[inline(always)]
4283 fn default() -> Dhtmem42 {
4284 Dhtmem42(0)
4285 }
4286 }
4287 impl core::fmt::Debug for Dhtmem42 {
4288 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4289 f.debug_struct("Dhtmem42")
4290 .field("dhtmem_ram", &self.dhtmem_ram())
4291 .finish()
4292 }
4293 }
4294 #[cfg(feature = "defmt")]
4295 impl defmt::Format for Dhtmem42 {
4296 fn format(&self, f: defmt::Formatter) {
4297 #[derive(defmt :: Format)]
4298 struct Dhtmem42 {
4299 dhtmem_ram: u32,
4300 }
4301 let proxy = Dhtmem42 {
4302 dhtmem_ram: self.dhtmem_ram(),
4303 };
4304 defmt::write!(f, "{}", proxy)
4305 }
4306 }
4307 #[doc = "JPEG DHTMem tables"]
4308 #[repr(transparent)]
4309 #[derive(Copy, Clone, Eq, PartialEq)]
4310 pub struct Dhtmem43(pub u32);
4311 impl Dhtmem43 {
4312 #[doc = "DHTMem RAM"]
4313 #[inline(always)]
4314 pub const fn dhtmem_ram(&self) -> u32 {
4315 let val = (self.0 >> 0usize) & 0xffff_ffff;
4316 val as u32
4317 }
4318 #[doc = "DHTMem RAM"]
4319 #[inline(always)]
4320 pub fn set_dhtmem_ram(&mut self, val: u32) {
4321 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4322 }
4323 }
4324 impl Default for Dhtmem43 {
4325 #[inline(always)]
4326 fn default() -> Dhtmem43 {
4327 Dhtmem43(0)
4328 }
4329 }
4330 impl core::fmt::Debug for Dhtmem43 {
4331 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4332 f.debug_struct("Dhtmem43")
4333 .field("dhtmem_ram", &self.dhtmem_ram())
4334 .finish()
4335 }
4336 }
4337 #[cfg(feature = "defmt")]
4338 impl defmt::Format for Dhtmem43 {
4339 fn format(&self, f: defmt::Formatter) {
4340 #[derive(defmt :: Format)]
4341 struct Dhtmem43 {
4342 dhtmem_ram: u32,
4343 }
4344 let proxy = Dhtmem43 {
4345 dhtmem_ram: self.dhtmem_ram(),
4346 };
4347 defmt::write!(f, "{}", proxy)
4348 }
4349 }
4350 #[doc = "JPEG DHTMem tables"]
4351 #[repr(transparent)]
4352 #[derive(Copy, Clone, Eq, PartialEq)]
4353 pub struct Dhtmem44(pub u32);
4354 impl Dhtmem44 {
4355 #[doc = "DHTMem RAM"]
4356 #[inline(always)]
4357 pub const fn dhtmem_ram(&self) -> u32 {
4358 let val = (self.0 >> 0usize) & 0xffff_ffff;
4359 val as u32
4360 }
4361 #[doc = "DHTMem RAM"]
4362 #[inline(always)]
4363 pub fn set_dhtmem_ram(&mut self, val: u32) {
4364 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4365 }
4366 }
4367 impl Default for Dhtmem44 {
4368 #[inline(always)]
4369 fn default() -> Dhtmem44 {
4370 Dhtmem44(0)
4371 }
4372 }
4373 impl core::fmt::Debug for Dhtmem44 {
4374 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4375 f.debug_struct("Dhtmem44")
4376 .field("dhtmem_ram", &self.dhtmem_ram())
4377 .finish()
4378 }
4379 }
4380 #[cfg(feature = "defmt")]
4381 impl defmt::Format for Dhtmem44 {
4382 fn format(&self, f: defmt::Formatter) {
4383 #[derive(defmt :: Format)]
4384 struct Dhtmem44 {
4385 dhtmem_ram: u32,
4386 }
4387 let proxy = Dhtmem44 {
4388 dhtmem_ram: self.dhtmem_ram(),
4389 };
4390 defmt::write!(f, "{}", proxy)
4391 }
4392 }
4393 #[doc = "JPEG DHTMem tables"]
4394 #[repr(transparent)]
4395 #[derive(Copy, Clone, Eq, PartialEq)]
4396 pub struct Dhtmem45(pub u32);
4397 impl Dhtmem45 {
4398 #[doc = "DHTMem RAM"]
4399 #[inline(always)]
4400 pub const fn dhtmem_ram(&self) -> u32 {
4401 let val = (self.0 >> 0usize) & 0xffff_ffff;
4402 val as u32
4403 }
4404 #[doc = "DHTMem RAM"]
4405 #[inline(always)]
4406 pub fn set_dhtmem_ram(&mut self, val: u32) {
4407 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4408 }
4409 }
4410 impl Default for Dhtmem45 {
4411 #[inline(always)]
4412 fn default() -> Dhtmem45 {
4413 Dhtmem45(0)
4414 }
4415 }
4416 impl core::fmt::Debug for Dhtmem45 {
4417 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4418 f.debug_struct("Dhtmem45")
4419 .field("dhtmem_ram", &self.dhtmem_ram())
4420 .finish()
4421 }
4422 }
4423 #[cfg(feature = "defmt")]
4424 impl defmt::Format for Dhtmem45 {
4425 fn format(&self, f: defmt::Formatter) {
4426 #[derive(defmt :: Format)]
4427 struct Dhtmem45 {
4428 dhtmem_ram: u32,
4429 }
4430 let proxy = Dhtmem45 {
4431 dhtmem_ram: self.dhtmem_ram(),
4432 };
4433 defmt::write!(f, "{}", proxy)
4434 }
4435 }
4436 #[doc = "JPEG DHTMem tables"]
4437 #[repr(transparent)]
4438 #[derive(Copy, Clone, Eq, PartialEq)]
4439 pub struct Dhtmem46(pub u32);
4440 impl Dhtmem46 {
4441 #[doc = "DHTMem RAM"]
4442 #[inline(always)]
4443 pub const fn dhtmem_ram(&self) -> u32 {
4444 let val = (self.0 >> 0usize) & 0xffff_ffff;
4445 val as u32
4446 }
4447 #[doc = "DHTMem RAM"]
4448 #[inline(always)]
4449 pub fn set_dhtmem_ram(&mut self, val: u32) {
4450 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4451 }
4452 }
4453 impl Default for Dhtmem46 {
4454 #[inline(always)]
4455 fn default() -> Dhtmem46 {
4456 Dhtmem46(0)
4457 }
4458 }
4459 impl core::fmt::Debug for Dhtmem46 {
4460 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4461 f.debug_struct("Dhtmem46")
4462 .field("dhtmem_ram", &self.dhtmem_ram())
4463 .finish()
4464 }
4465 }
4466 #[cfg(feature = "defmt")]
4467 impl defmt::Format for Dhtmem46 {
4468 fn format(&self, f: defmt::Formatter) {
4469 #[derive(defmt :: Format)]
4470 struct Dhtmem46 {
4471 dhtmem_ram: u32,
4472 }
4473 let proxy = Dhtmem46 {
4474 dhtmem_ram: self.dhtmem_ram(),
4475 };
4476 defmt::write!(f, "{}", proxy)
4477 }
4478 }
4479 #[doc = "JPEG DHTMem tables"]
4480 #[repr(transparent)]
4481 #[derive(Copy, Clone, Eq, PartialEq)]
4482 pub struct Dhtmem47(pub u32);
4483 impl Dhtmem47 {
4484 #[doc = "DHTMem RAM"]
4485 #[inline(always)]
4486 pub const fn dhtmem_ram(&self) -> u32 {
4487 let val = (self.0 >> 0usize) & 0xffff_ffff;
4488 val as u32
4489 }
4490 #[doc = "DHTMem RAM"]
4491 #[inline(always)]
4492 pub fn set_dhtmem_ram(&mut self, val: u32) {
4493 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4494 }
4495 }
4496 impl Default for Dhtmem47 {
4497 #[inline(always)]
4498 fn default() -> Dhtmem47 {
4499 Dhtmem47(0)
4500 }
4501 }
4502 impl core::fmt::Debug for Dhtmem47 {
4503 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4504 f.debug_struct("Dhtmem47")
4505 .field("dhtmem_ram", &self.dhtmem_ram())
4506 .finish()
4507 }
4508 }
4509 #[cfg(feature = "defmt")]
4510 impl defmt::Format for Dhtmem47 {
4511 fn format(&self, f: defmt::Formatter) {
4512 #[derive(defmt :: Format)]
4513 struct Dhtmem47 {
4514 dhtmem_ram: u32,
4515 }
4516 let proxy = Dhtmem47 {
4517 dhtmem_ram: self.dhtmem_ram(),
4518 };
4519 defmt::write!(f, "{}", proxy)
4520 }
4521 }
4522 #[doc = "JPEG DHTMem tables"]
4523 #[repr(transparent)]
4524 #[derive(Copy, Clone, Eq, PartialEq)]
4525 pub struct Dhtmem48(pub u32);
4526 impl Dhtmem48 {
4527 #[doc = "DHTMem RAM"]
4528 #[inline(always)]
4529 pub const fn dhtmem_ram(&self) -> u32 {
4530 let val = (self.0 >> 0usize) & 0xffff_ffff;
4531 val as u32
4532 }
4533 #[doc = "DHTMem RAM"]
4534 #[inline(always)]
4535 pub fn set_dhtmem_ram(&mut self, val: u32) {
4536 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4537 }
4538 }
4539 impl Default for Dhtmem48 {
4540 #[inline(always)]
4541 fn default() -> Dhtmem48 {
4542 Dhtmem48(0)
4543 }
4544 }
4545 impl core::fmt::Debug for Dhtmem48 {
4546 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4547 f.debug_struct("Dhtmem48")
4548 .field("dhtmem_ram", &self.dhtmem_ram())
4549 .finish()
4550 }
4551 }
4552 #[cfg(feature = "defmt")]
4553 impl defmt::Format for Dhtmem48 {
4554 fn format(&self, f: defmt::Formatter) {
4555 #[derive(defmt :: Format)]
4556 struct Dhtmem48 {
4557 dhtmem_ram: u32,
4558 }
4559 let proxy = Dhtmem48 {
4560 dhtmem_ram: self.dhtmem_ram(),
4561 };
4562 defmt::write!(f, "{}", proxy)
4563 }
4564 }
4565 #[doc = "JPEG DHTMem tables"]
4566 #[repr(transparent)]
4567 #[derive(Copy, Clone, Eq, PartialEq)]
4568 pub struct Dhtmem49(pub u32);
4569 impl Dhtmem49 {
4570 #[doc = "DHTMem RAM"]
4571 #[inline(always)]
4572 pub const fn dhtmem_ram(&self) -> u32 {
4573 let val = (self.0 >> 0usize) & 0xffff_ffff;
4574 val as u32
4575 }
4576 #[doc = "DHTMem RAM"]
4577 #[inline(always)]
4578 pub fn set_dhtmem_ram(&mut self, val: u32) {
4579 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4580 }
4581 }
4582 impl Default for Dhtmem49 {
4583 #[inline(always)]
4584 fn default() -> Dhtmem49 {
4585 Dhtmem49(0)
4586 }
4587 }
4588 impl core::fmt::Debug for Dhtmem49 {
4589 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4590 f.debug_struct("Dhtmem49")
4591 .field("dhtmem_ram", &self.dhtmem_ram())
4592 .finish()
4593 }
4594 }
4595 #[cfg(feature = "defmt")]
4596 impl defmt::Format for Dhtmem49 {
4597 fn format(&self, f: defmt::Formatter) {
4598 #[derive(defmt :: Format)]
4599 struct Dhtmem49 {
4600 dhtmem_ram: u32,
4601 }
4602 let proxy = Dhtmem49 {
4603 dhtmem_ram: self.dhtmem_ram(),
4604 };
4605 defmt::write!(f, "{}", proxy)
4606 }
4607 }
4608 #[doc = "JPEG DHTMem tables"]
4609 #[repr(transparent)]
4610 #[derive(Copy, Clone, Eq, PartialEq)]
4611 pub struct Dhtmem5(pub u32);
4612 impl Dhtmem5 {
4613 #[doc = "DHTMem RAM"]
4614 #[inline(always)]
4615 pub const fn dhtmem_ram(&self) -> u32 {
4616 let val = (self.0 >> 0usize) & 0xffff_ffff;
4617 val as u32
4618 }
4619 #[doc = "DHTMem RAM"]
4620 #[inline(always)]
4621 pub fn set_dhtmem_ram(&mut self, val: u32) {
4622 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4623 }
4624 }
4625 impl Default for Dhtmem5 {
4626 #[inline(always)]
4627 fn default() -> Dhtmem5 {
4628 Dhtmem5(0)
4629 }
4630 }
4631 impl core::fmt::Debug for Dhtmem5 {
4632 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4633 f.debug_struct("Dhtmem5")
4634 .field("dhtmem_ram", &self.dhtmem_ram())
4635 .finish()
4636 }
4637 }
4638 #[cfg(feature = "defmt")]
4639 impl defmt::Format for Dhtmem5 {
4640 fn format(&self, f: defmt::Formatter) {
4641 #[derive(defmt :: Format)]
4642 struct Dhtmem5 {
4643 dhtmem_ram: u32,
4644 }
4645 let proxy = Dhtmem5 {
4646 dhtmem_ram: self.dhtmem_ram(),
4647 };
4648 defmt::write!(f, "{}", proxy)
4649 }
4650 }
4651 #[doc = "JPEG DHTMem tables"]
4652 #[repr(transparent)]
4653 #[derive(Copy, Clone, Eq, PartialEq)]
4654 pub struct Dhtmem50(pub u32);
4655 impl Dhtmem50 {
4656 #[doc = "DHTMem RAM"]
4657 #[inline(always)]
4658 pub const fn dhtmem_ram(&self) -> u32 {
4659 let val = (self.0 >> 0usize) & 0xffff_ffff;
4660 val as u32
4661 }
4662 #[doc = "DHTMem RAM"]
4663 #[inline(always)]
4664 pub fn set_dhtmem_ram(&mut self, val: u32) {
4665 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4666 }
4667 }
4668 impl Default for Dhtmem50 {
4669 #[inline(always)]
4670 fn default() -> Dhtmem50 {
4671 Dhtmem50(0)
4672 }
4673 }
4674 impl core::fmt::Debug for Dhtmem50 {
4675 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4676 f.debug_struct("Dhtmem50")
4677 .field("dhtmem_ram", &self.dhtmem_ram())
4678 .finish()
4679 }
4680 }
4681 #[cfg(feature = "defmt")]
4682 impl defmt::Format for Dhtmem50 {
4683 fn format(&self, f: defmt::Formatter) {
4684 #[derive(defmt :: Format)]
4685 struct Dhtmem50 {
4686 dhtmem_ram: u32,
4687 }
4688 let proxy = Dhtmem50 {
4689 dhtmem_ram: self.dhtmem_ram(),
4690 };
4691 defmt::write!(f, "{}", proxy)
4692 }
4693 }
4694 #[doc = "JPEG DHTMem tables"]
4695 #[repr(transparent)]
4696 #[derive(Copy, Clone, Eq, PartialEq)]
4697 pub struct Dhtmem51(pub u32);
4698 impl Dhtmem51 {
4699 #[doc = "DHTMem RAM"]
4700 #[inline(always)]
4701 pub const fn dhtmem_ram(&self) -> u32 {
4702 let val = (self.0 >> 0usize) & 0xffff_ffff;
4703 val as u32
4704 }
4705 #[doc = "DHTMem RAM"]
4706 #[inline(always)]
4707 pub fn set_dhtmem_ram(&mut self, val: u32) {
4708 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4709 }
4710 }
4711 impl Default for Dhtmem51 {
4712 #[inline(always)]
4713 fn default() -> Dhtmem51 {
4714 Dhtmem51(0)
4715 }
4716 }
4717 impl core::fmt::Debug for Dhtmem51 {
4718 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4719 f.debug_struct("Dhtmem51")
4720 .field("dhtmem_ram", &self.dhtmem_ram())
4721 .finish()
4722 }
4723 }
4724 #[cfg(feature = "defmt")]
4725 impl defmt::Format for Dhtmem51 {
4726 fn format(&self, f: defmt::Formatter) {
4727 #[derive(defmt :: Format)]
4728 struct Dhtmem51 {
4729 dhtmem_ram: u32,
4730 }
4731 let proxy = Dhtmem51 {
4732 dhtmem_ram: self.dhtmem_ram(),
4733 };
4734 defmt::write!(f, "{}", proxy)
4735 }
4736 }
4737 #[doc = "JPEG DHTMem tables"]
4738 #[repr(transparent)]
4739 #[derive(Copy, Clone, Eq, PartialEq)]
4740 pub struct Dhtmem52(pub u32);
4741 impl Dhtmem52 {
4742 #[doc = "DHTMem RAM"]
4743 #[inline(always)]
4744 pub const fn dhtmem_ram(&self) -> u32 {
4745 let val = (self.0 >> 0usize) & 0xffff_ffff;
4746 val as u32
4747 }
4748 #[doc = "DHTMem RAM"]
4749 #[inline(always)]
4750 pub fn set_dhtmem_ram(&mut self, val: u32) {
4751 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4752 }
4753 }
4754 impl Default for Dhtmem52 {
4755 #[inline(always)]
4756 fn default() -> Dhtmem52 {
4757 Dhtmem52(0)
4758 }
4759 }
4760 impl core::fmt::Debug for Dhtmem52 {
4761 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4762 f.debug_struct("Dhtmem52")
4763 .field("dhtmem_ram", &self.dhtmem_ram())
4764 .finish()
4765 }
4766 }
4767 #[cfg(feature = "defmt")]
4768 impl defmt::Format for Dhtmem52 {
4769 fn format(&self, f: defmt::Formatter) {
4770 #[derive(defmt :: Format)]
4771 struct Dhtmem52 {
4772 dhtmem_ram: u32,
4773 }
4774 let proxy = Dhtmem52 {
4775 dhtmem_ram: self.dhtmem_ram(),
4776 };
4777 defmt::write!(f, "{}", proxy)
4778 }
4779 }
4780 #[doc = "JPEG DHTMem tables"]
4781 #[repr(transparent)]
4782 #[derive(Copy, Clone, Eq, PartialEq)]
4783 pub struct Dhtmem53(pub u32);
4784 impl Dhtmem53 {
4785 #[doc = "DHTMem RAM"]
4786 #[inline(always)]
4787 pub const fn dhtmem_ram(&self) -> u32 {
4788 let val = (self.0 >> 0usize) & 0xffff_ffff;
4789 val as u32
4790 }
4791 #[doc = "DHTMem RAM"]
4792 #[inline(always)]
4793 pub fn set_dhtmem_ram(&mut self, val: u32) {
4794 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4795 }
4796 }
4797 impl Default for Dhtmem53 {
4798 #[inline(always)]
4799 fn default() -> Dhtmem53 {
4800 Dhtmem53(0)
4801 }
4802 }
4803 impl core::fmt::Debug for Dhtmem53 {
4804 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4805 f.debug_struct("Dhtmem53")
4806 .field("dhtmem_ram", &self.dhtmem_ram())
4807 .finish()
4808 }
4809 }
4810 #[cfg(feature = "defmt")]
4811 impl defmt::Format for Dhtmem53 {
4812 fn format(&self, f: defmt::Formatter) {
4813 #[derive(defmt :: Format)]
4814 struct Dhtmem53 {
4815 dhtmem_ram: u32,
4816 }
4817 let proxy = Dhtmem53 {
4818 dhtmem_ram: self.dhtmem_ram(),
4819 };
4820 defmt::write!(f, "{}", proxy)
4821 }
4822 }
4823 #[doc = "JPEG DHTMem tables"]
4824 #[repr(transparent)]
4825 #[derive(Copy, Clone, Eq, PartialEq)]
4826 pub struct Dhtmem54(pub u32);
4827 impl Dhtmem54 {
4828 #[doc = "DHTMem RAM"]
4829 #[inline(always)]
4830 pub const fn dhtmem_ram(&self) -> u32 {
4831 let val = (self.0 >> 0usize) & 0xffff_ffff;
4832 val as u32
4833 }
4834 #[doc = "DHTMem RAM"]
4835 #[inline(always)]
4836 pub fn set_dhtmem_ram(&mut self, val: u32) {
4837 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4838 }
4839 }
4840 impl Default for Dhtmem54 {
4841 #[inline(always)]
4842 fn default() -> Dhtmem54 {
4843 Dhtmem54(0)
4844 }
4845 }
4846 impl core::fmt::Debug for Dhtmem54 {
4847 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4848 f.debug_struct("Dhtmem54")
4849 .field("dhtmem_ram", &self.dhtmem_ram())
4850 .finish()
4851 }
4852 }
4853 #[cfg(feature = "defmt")]
4854 impl defmt::Format for Dhtmem54 {
4855 fn format(&self, f: defmt::Formatter) {
4856 #[derive(defmt :: Format)]
4857 struct Dhtmem54 {
4858 dhtmem_ram: u32,
4859 }
4860 let proxy = Dhtmem54 {
4861 dhtmem_ram: self.dhtmem_ram(),
4862 };
4863 defmt::write!(f, "{}", proxy)
4864 }
4865 }
4866 #[doc = "JPEG DHTMem tables"]
4867 #[repr(transparent)]
4868 #[derive(Copy, Clone, Eq, PartialEq)]
4869 pub struct Dhtmem55(pub u32);
4870 impl Dhtmem55 {
4871 #[doc = "DHTMem RAM"]
4872 #[inline(always)]
4873 pub const fn dhtmem_ram(&self) -> u32 {
4874 let val = (self.0 >> 0usize) & 0xffff_ffff;
4875 val as u32
4876 }
4877 #[doc = "DHTMem RAM"]
4878 #[inline(always)]
4879 pub fn set_dhtmem_ram(&mut self, val: u32) {
4880 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4881 }
4882 }
4883 impl Default for Dhtmem55 {
4884 #[inline(always)]
4885 fn default() -> Dhtmem55 {
4886 Dhtmem55(0)
4887 }
4888 }
4889 impl core::fmt::Debug for Dhtmem55 {
4890 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4891 f.debug_struct("Dhtmem55")
4892 .field("dhtmem_ram", &self.dhtmem_ram())
4893 .finish()
4894 }
4895 }
4896 #[cfg(feature = "defmt")]
4897 impl defmt::Format for Dhtmem55 {
4898 fn format(&self, f: defmt::Formatter) {
4899 #[derive(defmt :: Format)]
4900 struct Dhtmem55 {
4901 dhtmem_ram: u32,
4902 }
4903 let proxy = Dhtmem55 {
4904 dhtmem_ram: self.dhtmem_ram(),
4905 };
4906 defmt::write!(f, "{}", proxy)
4907 }
4908 }
4909 #[doc = "JPEG DHTMem tables"]
4910 #[repr(transparent)]
4911 #[derive(Copy, Clone, Eq, PartialEq)]
4912 pub struct Dhtmem56(pub u32);
4913 impl Dhtmem56 {
4914 #[doc = "DHTMem RAM"]
4915 #[inline(always)]
4916 pub const fn dhtmem_ram(&self) -> u32 {
4917 let val = (self.0 >> 0usize) & 0xffff_ffff;
4918 val as u32
4919 }
4920 #[doc = "DHTMem RAM"]
4921 #[inline(always)]
4922 pub fn set_dhtmem_ram(&mut self, val: u32) {
4923 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4924 }
4925 }
4926 impl Default for Dhtmem56 {
4927 #[inline(always)]
4928 fn default() -> Dhtmem56 {
4929 Dhtmem56(0)
4930 }
4931 }
4932 impl core::fmt::Debug for Dhtmem56 {
4933 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4934 f.debug_struct("Dhtmem56")
4935 .field("dhtmem_ram", &self.dhtmem_ram())
4936 .finish()
4937 }
4938 }
4939 #[cfg(feature = "defmt")]
4940 impl defmt::Format for Dhtmem56 {
4941 fn format(&self, f: defmt::Formatter) {
4942 #[derive(defmt :: Format)]
4943 struct Dhtmem56 {
4944 dhtmem_ram: u32,
4945 }
4946 let proxy = Dhtmem56 {
4947 dhtmem_ram: self.dhtmem_ram(),
4948 };
4949 defmt::write!(f, "{}", proxy)
4950 }
4951 }
4952 #[doc = "JPEG DHTMem tables"]
4953 #[repr(transparent)]
4954 #[derive(Copy, Clone, Eq, PartialEq)]
4955 pub struct Dhtmem57(pub u32);
4956 impl Dhtmem57 {
4957 #[doc = "DHTMem RAM"]
4958 #[inline(always)]
4959 pub const fn dhtmem_ram(&self) -> u32 {
4960 let val = (self.0 >> 0usize) & 0xffff_ffff;
4961 val as u32
4962 }
4963 #[doc = "DHTMem RAM"]
4964 #[inline(always)]
4965 pub fn set_dhtmem_ram(&mut self, val: u32) {
4966 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
4967 }
4968 }
4969 impl Default for Dhtmem57 {
4970 #[inline(always)]
4971 fn default() -> Dhtmem57 {
4972 Dhtmem57(0)
4973 }
4974 }
4975 impl core::fmt::Debug for Dhtmem57 {
4976 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
4977 f.debug_struct("Dhtmem57")
4978 .field("dhtmem_ram", &self.dhtmem_ram())
4979 .finish()
4980 }
4981 }
4982 #[cfg(feature = "defmt")]
4983 impl defmt::Format for Dhtmem57 {
4984 fn format(&self, f: defmt::Formatter) {
4985 #[derive(defmt :: Format)]
4986 struct Dhtmem57 {
4987 dhtmem_ram: u32,
4988 }
4989 let proxy = Dhtmem57 {
4990 dhtmem_ram: self.dhtmem_ram(),
4991 };
4992 defmt::write!(f, "{}", proxy)
4993 }
4994 }
4995 #[doc = "JPEG DHTMem tables"]
4996 #[repr(transparent)]
4997 #[derive(Copy, Clone, Eq, PartialEq)]
4998 pub struct Dhtmem58(pub u32);
4999 impl Dhtmem58 {
5000 #[doc = "DHTMem RAM"]
5001 #[inline(always)]
5002 pub const fn dhtmem_ram(&self) -> u32 {
5003 let val = (self.0 >> 0usize) & 0xffff_ffff;
5004 val as u32
5005 }
5006 #[doc = "DHTMem RAM"]
5007 #[inline(always)]
5008 pub fn set_dhtmem_ram(&mut self, val: u32) {
5009 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5010 }
5011 }
5012 impl Default for Dhtmem58 {
5013 #[inline(always)]
5014 fn default() -> Dhtmem58 {
5015 Dhtmem58(0)
5016 }
5017 }
5018 impl core::fmt::Debug for Dhtmem58 {
5019 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5020 f.debug_struct("Dhtmem58")
5021 .field("dhtmem_ram", &self.dhtmem_ram())
5022 .finish()
5023 }
5024 }
5025 #[cfg(feature = "defmt")]
5026 impl defmt::Format for Dhtmem58 {
5027 fn format(&self, f: defmt::Formatter) {
5028 #[derive(defmt :: Format)]
5029 struct Dhtmem58 {
5030 dhtmem_ram: u32,
5031 }
5032 let proxy = Dhtmem58 {
5033 dhtmem_ram: self.dhtmem_ram(),
5034 };
5035 defmt::write!(f, "{}", proxy)
5036 }
5037 }
5038 #[doc = "JPEG DHTMem tables"]
5039 #[repr(transparent)]
5040 #[derive(Copy, Clone, Eq, PartialEq)]
5041 pub struct Dhtmem59(pub u32);
5042 impl Dhtmem59 {
5043 #[doc = "DHTMem RAM"]
5044 #[inline(always)]
5045 pub const fn dhtmem_ram(&self) -> u32 {
5046 let val = (self.0 >> 0usize) & 0xffff_ffff;
5047 val as u32
5048 }
5049 #[doc = "DHTMem RAM"]
5050 #[inline(always)]
5051 pub fn set_dhtmem_ram(&mut self, val: u32) {
5052 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5053 }
5054 }
5055 impl Default for Dhtmem59 {
5056 #[inline(always)]
5057 fn default() -> Dhtmem59 {
5058 Dhtmem59(0)
5059 }
5060 }
5061 impl core::fmt::Debug for Dhtmem59 {
5062 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5063 f.debug_struct("Dhtmem59")
5064 .field("dhtmem_ram", &self.dhtmem_ram())
5065 .finish()
5066 }
5067 }
5068 #[cfg(feature = "defmt")]
5069 impl defmt::Format for Dhtmem59 {
5070 fn format(&self, f: defmt::Formatter) {
5071 #[derive(defmt :: Format)]
5072 struct Dhtmem59 {
5073 dhtmem_ram: u32,
5074 }
5075 let proxy = Dhtmem59 {
5076 dhtmem_ram: self.dhtmem_ram(),
5077 };
5078 defmt::write!(f, "{}", proxy)
5079 }
5080 }
5081 #[doc = "JPEG DHTMem tables"]
5082 #[repr(transparent)]
5083 #[derive(Copy, Clone, Eq, PartialEq)]
5084 pub struct Dhtmem6(pub u32);
5085 impl Dhtmem6 {
5086 #[doc = "DHTMem RAM"]
5087 #[inline(always)]
5088 pub const fn dhtmem_ram(&self) -> u32 {
5089 let val = (self.0 >> 0usize) & 0xffff_ffff;
5090 val as u32
5091 }
5092 #[doc = "DHTMem RAM"]
5093 #[inline(always)]
5094 pub fn set_dhtmem_ram(&mut self, val: u32) {
5095 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5096 }
5097 }
5098 impl Default for Dhtmem6 {
5099 #[inline(always)]
5100 fn default() -> Dhtmem6 {
5101 Dhtmem6(0)
5102 }
5103 }
5104 impl core::fmt::Debug for Dhtmem6 {
5105 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5106 f.debug_struct("Dhtmem6")
5107 .field("dhtmem_ram", &self.dhtmem_ram())
5108 .finish()
5109 }
5110 }
5111 #[cfg(feature = "defmt")]
5112 impl defmt::Format for Dhtmem6 {
5113 fn format(&self, f: defmt::Formatter) {
5114 #[derive(defmt :: Format)]
5115 struct Dhtmem6 {
5116 dhtmem_ram: u32,
5117 }
5118 let proxy = Dhtmem6 {
5119 dhtmem_ram: self.dhtmem_ram(),
5120 };
5121 defmt::write!(f, "{}", proxy)
5122 }
5123 }
5124 #[doc = "JPEG DHTMem tables"]
5125 #[repr(transparent)]
5126 #[derive(Copy, Clone, Eq, PartialEq)]
5127 pub struct Dhtmem60(pub u32);
5128 impl Dhtmem60 {
5129 #[doc = "DHTMem RAM"]
5130 #[inline(always)]
5131 pub const fn dhtmem_ram(&self) -> u32 {
5132 let val = (self.0 >> 0usize) & 0xffff_ffff;
5133 val as u32
5134 }
5135 #[doc = "DHTMem RAM"]
5136 #[inline(always)]
5137 pub fn set_dhtmem_ram(&mut self, val: u32) {
5138 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5139 }
5140 }
5141 impl Default for Dhtmem60 {
5142 #[inline(always)]
5143 fn default() -> Dhtmem60 {
5144 Dhtmem60(0)
5145 }
5146 }
5147 impl core::fmt::Debug for Dhtmem60 {
5148 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5149 f.debug_struct("Dhtmem60")
5150 .field("dhtmem_ram", &self.dhtmem_ram())
5151 .finish()
5152 }
5153 }
5154 #[cfg(feature = "defmt")]
5155 impl defmt::Format for Dhtmem60 {
5156 fn format(&self, f: defmt::Formatter) {
5157 #[derive(defmt :: Format)]
5158 struct Dhtmem60 {
5159 dhtmem_ram: u32,
5160 }
5161 let proxy = Dhtmem60 {
5162 dhtmem_ram: self.dhtmem_ram(),
5163 };
5164 defmt::write!(f, "{}", proxy)
5165 }
5166 }
5167 #[doc = "JPEG DHTMem tables"]
5168 #[repr(transparent)]
5169 #[derive(Copy, Clone, Eq, PartialEq)]
5170 pub struct Dhtmem61(pub u32);
5171 impl Dhtmem61 {
5172 #[doc = "DHTMem RAM"]
5173 #[inline(always)]
5174 pub const fn dhtmem_ram(&self) -> u32 {
5175 let val = (self.0 >> 0usize) & 0xffff_ffff;
5176 val as u32
5177 }
5178 #[doc = "DHTMem RAM"]
5179 #[inline(always)]
5180 pub fn set_dhtmem_ram(&mut self, val: u32) {
5181 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5182 }
5183 }
5184 impl Default for Dhtmem61 {
5185 #[inline(always)]
5186 fn default() -> Dhtmem61 {
5187 Dhtmem61(0)
5188 }
5189 }
5190 impl core::fmt::Debug for Dhtmem61 {
5191 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5192 f.debug_struct("Dhtmem61")
5193 .field("dhtmem_ram", &self.dhtmem_ram())
5194 .finish()
5195 }
5196 }
5197 #[cfg(feature = "defmt")]
5198 impl defmt::Format for Dhtmem61 {
5199 fn format(&self, f: defmt::Formatter) {
5200 #[derive(defmt :: Format)]
5201 struct Dhtmem61 {
5202 dhtmem_ram: u32,
5203 }
5204 let proxy = Dhtmem61 {
5205 dhtmem_ram: self.dhtmem_ram(),
5206 };
5207 defmt::write!(f, "{}", proxy)
5208 }
5209 }
5210 #[doc = "JPEG DHTMem tables"]
5211 #[repr(transparent)]
5212 #[derive(Copy, Clone, Eq, PartialEq)]
5213 pub struct Dhtmem62(pub u32);
5214 impl Dhtmem62 {
5215 #[doc = "DHTMem RAM"]
5216 #[inline(always)]
5217 pub const fn dhtmem_ram(&self) -> u32 {
5218 let val = (self.0 >> 0usize) & 0xffff_ffff;
5219 val as u32
5220 }
5221 #[doc = "DHTMem RAM"]
5222 #[inline(always)]
5223 pub fn set_dhtmem_ram(&mut self, val: u32) {
5224 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5225 }
5226 }
5227 impl Default for Dhtmem62 {
5228 #[inline(always)]
5229 fn default() -> Dhtmem62 {
5230 Dhtmem62(0)
5231 }
5232 }
5233 impl core::fmt::Debug for Dhtmem62 {
5234 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5235 f.debug_struct("Dhtmem62")
5236 .field("dhtmem_ram", &self.dhtmem_ram())
5237 .finish()
5238 }
5239 }
5240 #[cfg(feature = "defmt")]
5241 impl defmt::Format for Dhtmem62 {
5242 fn format(&self, f: defmt::Formatter) {
5243 #[derive(defmt :: Format)]
5244 struct Dhtmem62 {
5245 dhtmem_ram: u32,
5246 }
5247 let proxy = Dhtmem62 {
5248 dhtmem_ram: self.dhtmem_ram(),
5249 };
5250 defmt::write!(f, "{}", proxy)
5251 }
5252 }
5253 #[doc = "JPEG DHTMem tables"]
5254 #[repr(transparent)]
5255 #[derive(Copy, Clone, Eq, PartialEq)]
5256 pub struct Dhtmem63(pub u32);
5257 impl Dhtmem63 {
5258 #[doc = "DHTMem RAM"]
5259 #[inline(always)]
5260 pub const fn dhtmem_ram(&self) -> u32 {
5261 let val = (self.0 >> 0usize) & 0xffff_ffff;
5262 val as u32
5263 }
5264 #[doc = "DHTMem RAM"]
5265 #[inline(always)]
5266 pub fn set_dhtmem_ram(&mut self, val: u32) {
5267 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5268 }
5269 }
5270 impl Default for Dhtmem63 {
5271 #[inline(always)]
5272 fn default() -> Dhtmem63 {
5273 Dhtmem63(0)
5274 }
5275 }
5276 impl core::fmt::Debug for Dhtmem63 {
5277 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5278 f.debug_struct("Dhtmem63")
5279 .field("dhtmem_ram", &self.dhtmem_ram())
5280 .finish()
5281 }
5282 }
5283 #[cfg(feature = "defmt")]
5284 impl defmt::Format for Dhtmem63 {
5285 fn format(&self, f: defmt::Formatter) {
5286 #[derive(defmt :: Format)]
5287 struct Dhtmem63 {
5288 dhtmem_ram: u32,
5289 }
5290 let proxy = Dhtmem63 {
5291 dhtmem_ram: self.dhtmem_ram(),
5292 };
5293 defmt::write!(f, "{}", proxy)
5294 }
5295 }
5296 #[doc = "JPEG DHTMem tables"]
5297 #[repr(transparent)]
5298 #[derive(Copy, Clone, Eq, PartialEq)]
5299 pub struct Dhtmem64(pub u32);
5300 impl Dhtmem64 {
5301 #[doc = "DHTMem RAM"]
5302 #[inline(always)]
5303 pub const fn dhtmem_ram(&self) -> u32 {
5304 let val = (self.0 >> 0usize) & 0xffff_ffff;
5305 val as u32
5306 }
5307 #[doc = "DHTMem RAM"]
5308 #[inline(always)]
5309 pub fn set_dhtmem_ram(&mut self, val: u32) {
5310 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5311 }
5312 }
5313 impl Default for Dhtmem64 {
5314 #[inline(always)]
5315 fn default() -> Dhtmem64 {
5316 Dhtmem64(0)
5317 }
5318 }
5319 impl core::fmt::Debug for Dhtmem64 {
5320 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5321 f.debug_struct("Dhtmem64")
5322 .field("dhtmem_ram", &self.dhtmem_ram())
5323 .finish()
5324 }
5325 }
5326 #[cfg(feature = "defmt")]
5327 impl defmt::Format for Dhtmem64 {
5328 fn format(&self, f: defmt::Formatter) {
5329 #[derive(defmt :: Format)]
5330 struct Dhtmem64 {
5331 dhtmem_ram: u32,
5332 }
5333 let proxy = Dhtmem64 {
5334 dhtmem_ram: self.dhtmem_ram(),
5335 };
5336 defmt::write!(f, "{}", proxy)
5337 }
5338 }
5339 #[doc = "JPEG DHTMem tables"]
5340 #[repr(transparent)]
5341 #[derive(Copy, Clone, Eq, PartialEq)]
5342 pub struct Dhtmem65(pub u32);
5343 impl Dhtmem65 {
5344 #[doc = "DHTMem RAM"]
5345 #[inline(always)]
5346 pub const fn dhtmem_ram(&self) -> u32 {
5347 let val = (self.0 >> 0usize) & 0xffff_ffff;
5348 val as u32
5349 }
5350 #[doc = "DHTMem RAM"]
5351 #[inline(always)]
5352 pub fn set_dhtmem_ram(&mut self, val: u32) {
5353 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5354 }
5355 }
5356 impl Default for Dhtmem65 {
5357 #[inline(always)]
5358 fn default() -> Dhtmem65 {
5359 Dhtmem65(0)
5360 }
5361 }
5362 impl core::fmt::Debug for Dhtmem65 {
5363 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5364 f.debug_struct("Dhtmem65")
5365 .field("dhtmem_ram", &self.dhtmem_ram())
5366 .finish()
5367 }
5368 }
5369 #[cfg(feature = "defmt")]
5370 impl defmt::Format for Dhtmem65 {
5371 fn format(&self, f: defmt::Formatter) {
5372 #[derive(defmt :: Format)]
5373 struct Dhtmem65 {
5374 dhtmem_ram: u32,
5375 }
5376 let proxy = Dhtmem65 {
5377 dhtmem_ram: self.dhtmem_ram(),
5378 };
5379 defmt::write!(f, "{}", proxy)
5380 }
5381 }
5382 #[doc = "JPEG DHTMem tables"]
5383 #[repr(transparent)]
5384 #[derive(Copy, Clone, Eq, PartialEq)]
5385 pub struct Dhtmem66(pub u32);
5386 impl Dhtmem66 {
5387 #[doc = "DHTMem RAM"]
5388 #[inline(always)]
5389 pub const fn dhtmem_ram(&self) -> u32 {
5390 let val = (self.0 >> 0usize) & 0xffff_ffff;
5391 val as u32
5392 }
5393 #[doc = "DHTMem RAM"]
5394 #[inline(always)]
5395 pub fn set_dhtmem_ram(&mut self, val: u32) {
5396 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5397 }
5398 }
5399 impl Default for Dhtmem66 {
5400 #[inline(always)]
5401 fn default() -> Dhtmem66 {
5402 Dhtmem66(0)
5403 }
5404 }
5405 impl core::fmt::Debug for Dhtmem66 {
5406 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5407 f.debug_struct("Dhtmem66")
5408 .field("dhtmem_ram", &self.dhtmem_ram())
5409 .finish()
5410 }
5411 }
5412 #[cfg(feature = "defmt")]
5413 impl defmt::Format for Dhtmem66 {
5414 fn format(&self, f: defmt::Formatter) {
5415 #[derive(defmt :: Format)]
5416 struct Dhtmem66 {
5417 dhtmem_ram: u32,
5418 }
5419 let proxy = Dhtmem66 {
5420 dhtmem_ram: self.dhtmem_ram(),
5421 };
5422 defmt::write!(f, "{}", proxy)
5423 }
5424 }
5425 #[doc = "JPEG DHTMem tables"]
5426 #[repr(transparent)]
5427 #[derive(Copy, Clone, Eq, PartialEq)]
5428 pub struct Dhtmem67(pub u32);
5429 impl Dhtmem67 {
5430 #[doc = "DHTMem RAM"]
5431 #[inline(always)]
5432 pub const fn dhtmem_ram(&self) -> u32 {
5433 let val = (self.0 >> 0usize) & 0xffff_ffff;
5434 val as u32
5435 }
5436 #[doc = "DHTMem RAM"]
5437 #[inline(always)]
5438 pub fn set_dhtmem_ram(&mut self, val: u32) {
5439 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5440 }
5441 }
5442 impl Default for Dhtmem67 {
5443 #[inline(always)]
5444 fn default() -> Dhtmem67 {
5445 Dhtmem67(0)
5446 }
5447 }
5448 impl core::fmt::Debug for Dhtmem67 {
5449 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5450 f.debug_struct("Dhtmem67")
5451 .field("dhtmem_ram", &self.dhtmem_ram())
5452 .finish()
5453 }
5454 }
5455 #[cfg(feature = "defmt")]
5456 impl defmt::Format for Dhtmem67 {
5457 fn format(&self, f: defmt::Formatter) {
5458 #[derive(defmt :: Format)]
5459 struct Dhtmem67 {
5460 dhtmem_ram: u32,
5461 }
5462 let proxy = Dhtmem67 {
5463 dhtmem_ram: self.dhtmem_ram(),
5464 };
5465 defmt::write!(f, "{}", proxy)
5466 }
5467 }
5468 #[doc = "JPEG DHTMem tables"]
5469 #[repr(transparent)]
5470 #[derive(Copy, Clone, Eq, PartialEq)]
5471 pub struct Dhtmem68(pub u32);
5472 impl Dhtmem68 {
5473 #[doc = "DHTMem RAM"]
5474 #[inline(always)]
5475 pub const fn dhtmem_ram(&self) -> u32 {
5476 let val = (self.0 >> 0usize) & 0xffff_ffff;
5477 val as u32
5478 }
5479 #[doc = "DHTMem RAM"]
5480 #[inline(always)]
5481 pub fn set_dhtmem_ram(&mut self, val: u32) {
5482 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5483 }
5484 }
5485 impl Default for Dhtmem68 {
5486 #[inline(always)]
5487 fn default() -> Dhtmem68 {
5488 Dhtmem68(0)
5489 }
5490 }
5491 impl core::fmt::Debug for Dhtmem68 {
5492 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5493 f.debug_struct("Dhtmem68")
5494 .field("dhtmem_ram", &self.dhtmem_ram())
5495 .finish()
5496 }
5497 }
5498 #[cfg(feature = "defmt")]
5499 impl defmt::Format for Dhtmem68 {
5500 fn format(&self, f: defmt::Formatter) {
5501 #[derive(defmt :: Format)]
5502 struct Dhtmem68 {
5503 dhtmem_ram: u32,
5504 }
5505 let proxy = Dhtmem68 {
5506 dhtmem_ram: self.dhtmem_ram(),
5507 };
5508 defmt::write!(f, "{}", proxy)
5509 }
5510 }
5511 #[doc = "JPEG DHTMem tables"]
5512 #[repr(transparent)]
5513 #[derive(Copy, Clone, Eq, PartialEq)]
5514 pub struct Dhtmem69(pub u32);
5515 impl Dhtmem69 {
5516 #[doc = "DHTMem RAM"]
5517 #[inline(always)]
5518 pub const fn dhtmem_ram(&self) -> u32 {
5519 let val = (self.0 >> 0usize) & 0xffff_ffff;
5520 val as u32
5521 }
5522 #[doc = "DHTMem RAM"]
5523 #[inline(always)]
5524 pub fn set_dhtmem_ram(&mut self, val: u32) {
5525 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5526 }
5527 }
5528 impl Default for Dhtmem69 {
5529 #[inline(always)]
5530 fn default() -> Dhtmem69 {
5531 Dhtmem69(0)
5532 }
5533 }
5534 impl core::fmt::Debug for Dhtmem69 {
5535 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5536 f.debug_struct("Dhtmem69")
5537 .field("dhtmem_ram", &self.dhtmem_ram())
5538 .finish()
5539 }
5540 }
5541 #[cfg(feature = "defmt")]
5542 impl defmt::Format for Dhtmem69 {
5543 fn format(&self, f: defmt::Formatter) {
5544 #[derive(defmt :: Format)]
5545 struct Dhtmem69 {
5546 dhtmem_ram: u32,
5547 }
5548 let proxy = Dhtmem69 {
5549 dhtmem_ram: self.dhtmem_ram(),
5550 };
5551 defmt::write!(f, "{}", proxy)
5552 }
5553 }
5554 #[doc = "JPEG DHTMem tables"]
5555 #[repr(transparent)]
5556 #[derive(Copy, Clone, Eq, PartialEq)]
5557 pub struct Dhtmem7(pub u32);
5558 impl Dhtmem7 {
5559 #[doc = "DHTMem RAM"]
5560 #[inline(always)]
5561 pub const fn dhtmem_ram(&self) -> u32 {
5562 let val = (self.0 >> 0usize) & 0xffff_ffff;
5563 val as u32
5564 }
5565 #[doc = "DHTMem RAM"]
5566 #[inline(always)]
5567 pub fn set_dhtmem_ram(&mut self, val: u32) {
5568 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5569 }
5570 }
5571 impl Default for Dhtmem7 {
5572 #[inline(always)]
5573 fn default() -> Dhtmem7 {
5574 Dhtmem7(0)
5575 }
5576 }
5577 impl core::fmt::Debug for Dhtmem7 {
5578 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5579 f.debug_struct("Dhtmem7")
5580 .field("dhtmem_ram", &self.dhtmem_ram())
5581 .finish()
5582 }
5583 }
5584 #[cfg(feature = "defmt")]
5585 impl defmt::Format for Dhtmem7 {
5586 fn format(&self, f: defmt::Formatter) {
5587 #[derive(defmt :: Format)]
5588 struct Dhtmem7 {
5589 dhtmem_ram: u32,
5590 }
5591 let proxy = Dhtmem7 {
5592 dhtmem_ram: self.dhtmem_ram(),
5593 };
5594 defmt::write!(f, "{}", proxy)
5595 }
5596 }
5597 #[doc = "JPEG DHTMem tables"]
5598 #[repr(transparent)]
5599 #[derive(Copy, Clone, Eq, PartialEq)]
5600 pub struct Dhtmem70(pub u32);
5601 impl Dhtmem70 {
5602 #[doc = "DHTMem RAM"]
5603 #[inline(always)]
5604 pub const fn dhtmem_ram(&self) -> u32 {
5605 let val = (self.0 >> 0usize) & 0xffff_ffff;
5606 val as u32
5607 }
5608 #[doc = "DHTMem RAM"]
5609 #[inline(always)]
5610 pub fn set_dhtmem_ram(&mut self, val: u32) {
5611 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5612 }
5613 }
5614 impl Default for Dhtmem70 {
5615 #[inline(always)]
5616 fn default() -> Dhtmem70 {
5617 Dhtmem70(0)
5618 }
5619 }
5620 impl core::fmt::Debug for Dhtmem70 {
5621 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5622 f.debug_struct("Dhtmem70")
5623 .field("dhtmem_ram", &self.dhtmem_ram())
5624 .finish()
5625 }
5626 }
5627 #[cfg(feature = "defmt")]
5628 impl defmt::Format for Dhtmem70 {
5629 fn format(&self, f: defmt::Formatter) {
5630 #[derive(defmt :: Format)]
5631 struct Dhtmem70 {
5632 dhtmem_ram: u32,
5633 }
5634 let proxy = Dhtmem70 {
5635 dhtmem_ram: self.dhtmem_ram(),
5636 };
5637 defmt::write!(f, "{}", proxy)
5638 }
5639 }
5640 #[doc = "JPEG DHTMem tables"]
5641 #[repr(transparent)]
5642 #[derive(Copy, Clone, Eq, PartialEq)]
5643 pub struct Dhtmem71(pub u32);
5644 impl Dhtmem71 {
5645 #[doc = "DHTMem RAM"]
5646 #[inline(always)]
5647 pub const fn dhtmem_ram(&self) -> u32 {
5648 let val = (self.0 >> 0usize) & 0xffff_ffff;
5649 val as u32
5650 }
5651 #[doc = "DHTMem RAM"]
5652 #[inline(always)]
5653 pub fn set_dhtmem_ram(&mut self, val: u32) {
5654 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5655 }
5656 }
5657 impl Default for Dhtmem71 {
5658 #[inline(always)]
5659 fn default() -> Dhtmem71 {
5660 Dhtmem71(0)
5661 }
5662 }
5663 impl core::fmt::Debug for Dhtmem71 {
5664 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5665 f.debug_struct("Dhtmem71")
5666 .field("dhtmem_ram", &self.dhtmem_ram())
5667 .finish()
5668 }
5669 }
5670 #[cfg(feature = "defmt")]
5671 impl defmt::Format for Dhtmem71 {
5672 fn format(&self, f: defmt::Formatter) {
5673 #[derive(defmt :: Format)]
5674 struct Dhtmem71 {
5675 dhtmem_ram: u32,
5676 }
5677 let proxy = Dhtmem71 {
5678 dhtmem_ram: self.dhtmem_ram(),
5679 };
5680 defmt::write!(f, "{}", proxy)
5681 }
5682 }
5683 #[doc = "JPEG DHTMem tables"]
5684 #[repr(transparent)]
5685 #[derive(Copy, Clone, Eq, PartialEq)]
5686 pub struct Dhtmem72(pub u32);
5687 impl Dhtmem72 {
5688 #[doc = "DHTMem RAM"]
5689 #[inline(always)]
5690 pub const fn dhtmem_ram(&self) -> u32 {
5691 let val = (self.0 >> 0usize) & 0xffff_ffff;
5692 val as u32
5693 }
5694 #[doc = "DHTMem RAM"]
5695 #[inline(always)]
5696 pub fn set_dhtmem_ram(&mut self, val: u32) {
5697 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5698 }
5699 }
5700 impl Default for Dhtmem72 {
5701 #[inline(always)]
5702 fn default() -> Dhtmem72 {
5703 Dhtmem72(0)
5704 }
5705 }
5706 impl core::fmt::Debug for Dhtmem72 {
5707 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5708 f.debug_struct("Dhtmem72")
5709 .field("dhtmem_ram", &self.dhtmem_ram())
5710 .finish()
5711 }
5712 }
5713 #[cfg(feature = "defmt")]
5714 impl defmt::Format for Dhtmem72 {
5715 fn format(&self, f: defmt::Formatter) {
5716 #[derive(defmt :: Format)]
5717 struct Dhtmem72 {
5718 dhtmem_ram: u32,
5719 }
5720 let proxy = Dhtmem72 {
5721 dhtmem_ram: self.dhtmem_ram(),
5722 };
5723 defmt::write!(f, "{}", proxy)
5724 }
5725 }
5726 #[doc = "JPEG DHTMem tables"]
5727 #[repr(transparent)]
5728 #[derive(Copy, Clone, Eq, PartialEq)]
5729 pub struct Dhtmem73(pub u32);
5730 impl Dhtmem73 {
5731 #[doc = "DHTMem RAM"]
5732 #[inline(always)]
5733 pub const fn dhtmem_ram(&self) -> u32 {
5734 let val = (self.0 >> 0usize) & 0xffff_ffff;
5735 val as u32
5736 }
5737 #[doc = "DHTMem RAM"]
5738 #[inline(always)]
5739 pub fn set_dhtmem_ram(&mut self, val: u32) {
5740 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5741 }
5742 }
5743 impl Default for Dhtmem73 {
5744 #[inline(always)]
5745 fn default() -> Dhtmem73 {
5746 Dhtmem73(0)
5747 }
5748 }
5749 impl core::fmt::Debug for Dhtmem73 {
5750 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5751 f.debug_struct("Dhtmem73")
5752 .field("dhtmem_ram", &self.dhtmem_ram())
5753 .finish()
5754 }
5755 }
5756 #[cfg(feature = "defmt")]
5757 impl defmt::Format for Dhtmem73 {
5758 fn format(&self, f: defmt::Formatter) {
5759 #[derive(defmt :: Format)]
5760 struct Dhtmem73 {
5761 dhtmem_ram: u32,
5762 }
5763 let proxy = Dhtmem73 {
5764 dhtmem_ram: self.dhtmem_ram(),
5765 };
5766 defmt::write!(f, "{}", proxy)
5767 }
5768 }
5769 #[doc = "JPEG DHTMem tables"]
5770 #[repr(transparent)]
5771 #[derive(Copy, Clone, Eq, PartialEq)]
5772 pub struct Dhtmem74(pub u32);
5773 impl Dhtmem74 {
5774 #[doc = "DHTMem RAM"]
5775 #[inline(always)]
5776 pub const fn dhtmem_ram(&self) -> u32 {
5777 let val = (self.0 >> 0usize) & 0xffff_ffff;
5778 val as u32
5779 }
5780 #[doc = "DHTMem RAM"]
5781 #[inline(always)]
5782 pub fn set_dhtmem_ram(&mut self, val: u32) {
5783 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5784 }
5785 }
5786 impl Default for Dhtmem74 {
5787 #[inline(always)]
5788 fn default() -> Dhtmem74 {
5789 Dhtmem74(0)
5790 }
5791 }
5792 impl core::fmt::Debug for Dhtmem74 {
5793 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5794 f.debug_struct("Dhtmem74")
5795 .field("dhtmem_ram", &self.dhtmem_ram())
5796 .finish()
5797 }
5798 }
5799 #[cfg(feature = "defmt")]
5800 impl defmt::Format for Dhtmem74 {
5801 fn format(&self, f: defmt::Formatter) {
5802 #[derive(defmt :: Format)]
5803 struct Dhtmem74 {
5804 dhtmem_ram: u32,
5805 }
5806 let proxy = Dhtmem74 {
5807 dhtmem_ram: self.dhtmem_ram(),
5808 };
5809 defmt::write!(f, "{}", proxy)
5810 }
5811 }
5812 #[doc = "JPEG DHTMem tables"]
5813 #[repr(transparent)]
5814 #[derive(Copy, Clone, Eq, PartialEq)]
5815 pub struct Dhtmem75(pub u32);
5816 impl Dhtmem75 {
5817 #[doc = "DHTMem RAM"]
5818 #[inline(always)]
5819 pub const fn dhtmem_ram(&self) -> u32 {
5820 let val = (self.0 >> 0usize) & 0xffff_ffff;
5821 val as u32
5822 }
5823 #[doc = "DHTMem RAM"]
5824 #[inline(always)]
5825 pub fn set_dhtmem_ram(&mut self, val: u32) {
5826 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5827 }
5828 }
5829 impl Default for Dhtmem75 {
5830 #[inline(always)]
5831 fn default() -> Dhtmem75 {
5832 Dhtmem75(0)
5833 }
5834 }
5835 impl core::fmt::Debug for Dhtmem75 {
5836 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5837 f.debug_struct("Dhtmem75")
5838 .field("dhtmem_ram", &self.dhtmem_ram())
5839 .finish()
5840 }
5841 }
5842 #[cfg(feature = "defmt")]
5843 impl defmt::Format for Dhtmem75 {
5844 fn format(&self, f: defmt::Formatter) {
5845 #[derive(defmt :: Format)]
5846 struct Dhtmem75 {
5847 dhtmem_ram: u32,
5848 }
5849 let proxy = Dhtmem75 {
5850 dhtmem_ram: self.dhtmem_ram(),
5851 };
5852 defmt::write!(f, "{}", proxy)
5853 }
5854 }
5855 #[doc = "JPEG DHTMem tables"]
5856 #[repr(transparent)]
5857 #[derive(Copy, Clone, Eq, PartialEq)]
5858 pub struct Dhtmem76(pub u32);
5859 impl Dhtmem76 {
5860 #[doc = "DHTMem RAM"]
5861 #[inline(always)]
5862 pub const fn dhtmem_ram(&self) -> u32 {
5863 let val = (self.0 >> 0usize) & 0xffff_ffff;
5864 val as u32
5865 }
5866 #[doc = "DHTMem RAM"]
5867 #[inline(always)]
5868 pub fn set_dhtmem_ram(&mut self, val: u32) {
5869 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5870 }
5871 }
5872 impl Default for Dhtmem76 {
5873 #[inline(always)]
5874 fn default() -> Dhtmem76 {
5875 Dhtmem76(0)
5876 }
5877 }
5878 impl core::fmt::Debug for Dhtmem76 {
5879 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5880 f.debug_struct("Dhtmem76")
5881 .field("dhtmem_ram", &self.dhtmem_ram())
5882 .finish()
5883 }
5884 }
5885 #[cfg(feature = "defmt")]
5886 impl defmt::Format for Dhtmem76 {
5887 fn format(&self, f: defmt::Formatter) {
5888 #[derive(defmt :: Format)]
5889 struct Dhtmem76 {
5890 dhtmem_ram: u32,
5891 }
5892 let proxy = Dhtmem76 {
5893 dhtmem_ram: self.dhtmem_ram(),
5894 };
5895 defmt::write!(f, "{}", proxy)
5896 }
5897 }
5898 #[doc = "JPEG DHTMem tables"]
5899 #[repr(transparent)]
5900 #[derive(Copy, Clone, Eq, PartialEq)]
5901 pub struct Dhtmem77(pub u32);
5902 impl Dhtmem77 {
5903 #[doc = "DHTMem RAM"]
5904 #[inline(always)]
5905 pub const fn dhtmem_ram(&self) -> u32 {
5906 let val = (self.0 >> 0usize) & 0xffff_ffff;
5907 val as u32
5908 }
5909 #[doc = "DHTMem RAM"]
5910 #[inline(always)]
5911 pub fn set_dhtmem_ram(&mut self, val: u32) {
5912 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5913 }
5914 }
5915 impl Default for Dhtmem77 {
5916 #[inline(always)]
5917 fn default() -> Dhtmem77 {
5918 Dhtmem77(0)
5919 }
5920 }
5921 impl core::fmt::Debug for Dhtmem77 {
5922 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5923 f.debug_struct("Dhtmem77")
5924 .field("dhtmem_ram", &self.dhtmem_ram())
5925 .finish()
5926 }
5927 }
5928 #[cfg(feature = "defmt")]
5929 impl defmt::Format for Dhtmem77 {
5930 fn format(&self, f: defmt::Formatter) {
5931 #[derive(defmt :: Format)]
5932 struct Dhtmem77 {
5933 dhtmem_ram: u32,
5934 }
5935 let proxy = Dhtmem77 {
5936 dhtmem_ram: self.dhtmem_ram(),
5937 };
5938 defmt::write!(f, "{}", proxy)
5939 }
5940 }
5941 #[doc = "JPEG DHTMem tables"]
5942 #[repr(transparent)]
5943 #[derive(Copy, Clone, Eq, PartialEq)]
5944 pub struct Dhtmem78(pub u32);
5945 impl Dhtmem78 {
5946 #[doc = "DHTMem RAM"]
5947 #[inline(always)]
5948 pub const fn dhtmem_ram(&self) -> u32 {
5949 let val = (self.0 >> 0usize) & 0xffff_ffff;
5950 val as u32
5951 }
5952 #[doc = "DHTMem RAM"]
5953 #[inline(always)]
5954 pub fn set_dhtmem_ram(&mut self, val: u32) {
5955 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5956 }
5957 }
5958 impl Default for Dhtmem78 {
5959 #[inline(always)]
5960 fn default() -> Dhtmem78 {
5961 Dhtmem78(0)
5962 }
5963 }
5964 impl core::fmt::Debug for Dhtmem78 {
5965 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
5966 f.debug_struct("Dhtmem78")
5967 .field("dhtmem_ram", &self.dhtmem_ram())
5968 .finish()
5969 }
5970 }
5971 #[cfg(feature = "defmt")]
5972 impl defmt::Format for Dhtmem78 {
5973 fn format(&self, f: defmt::Formatter) {
5974 #[derive(defmt :: Format)]
5975 struct Dhtmem78 {
5976 dhtmem_ram: u32,
5977 }
5978 let proxy = Dhtmem78 {
5979 dhtmem_ram: self.dhtmem_ram(),
5980 };
5981 defmt::write!(f, "{}", proxy)
5982 }
5983 }
5984 #[doc = "JPEG DHTMem tables"]
5985 #[repr(transparent)]
5986 #[derive(Copy, Clone, Eq, PartialEq)]
5987 pub struct Dhtmem79(pub u32);
5988 impl Dhtmem79 {
5989 #[doc = "DHTMem RAM"]
5990 #[inline(always)]
5991 pub const fn dhtmem_ram(&self) -> u32 {
5992 let val = (self.0 >> 0usize) & 0xffff_ffff;
5993 val as u32
5994 }
5995 #[doc = "DHTMem RAM"]
5996 #[inline(always)]
5997 pub fn set_dhtmem_ram(&mut self, val: u32) {
5998 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
5999 }
6000 }
6001 impl Default for Dhtmem79 {
6002 #[inline(always)]
6003 fn default() -> Dhtmem79 {
6004 Dhtmem79(0)
6005 }
6006 }
6007 impl core::fmt::Debug for Dhtmem79 {
6008 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6009 f.debug_struct("Dhtmem79")
6010 .field("dhtmem_ram", &self.dhtmem_ram())
6011 .finish()
6012 }
6013 }
6014 #[cfg(feature = "defmt")]
6015 impl defmt::Format for Dhtmem79 {
6016 fn format(&self, f: defmt::Formatter) {
6017 #[derive(defmt :: Format)]
6018 struct Dhtmem79 {
6019 dhtmem_ram: u32,
6020 }
6021 let proxy = Dhtmem79 {
6022 dhtmem_ram: self.dhtmem_ram(),
6023 };
6024 defmt::write!(f, "{}", proxy)
6025 }
6026 }
6027 #[doc = "JPEG DHTMem tables"]
6028 #[repr(transparent)]
6029 #[derive(Copy, Clone, Eq, PartialEq)]
6030 pub struct Dhtmem8(pub u32);
6031 impl Dhtmem8 {
6032 #[doc = "DHTMem RAM"]
6033 #[inline(always)]
6034 pub const fn dhtmem_ram(&self) -> u32 {
6035 let val = (self.0 >> 0usize) & 0xffff_ffff;
6036 val as u32
6037 }
6038 #[doc = "DHTMem RAM"]
6039 #[inline(always)]
6040 pub fn set_dhtmem_ram(&mut self, val: u32) {
6041 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6042 }
6043 }
6044 impl Default for Dhtmem8 {
6045 #[inline(always)]
6046 fn default() -> Dhtmem8 {
6047 Dhtmem8(0)
6048 }
6049 }
6050 impl core::fmt::Debug for Dhtmem8 {
6051 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6052 f.debug_struct("Dhtmem8")
6053 .field("dhtmem_ram", &self.dhtmem_ram())
6054 .finish()
6055 }
6056 }
6057 #[cfg(feature = "defmt")]
6058 impl defmt::Format for Dhtmem8 {
6059 fn format(&self, f: defmt::Formatter) {
6060 #[derive(defmt :: Format)]
6061 struct Dhtmem8 {
6062 dhtmem_ram: u32,
6063 }
6064 let proxy = Dhtmem8 {
6065 dhtmem_ram: self.dhtmem_ram(),
6066 };
6067 defmt::write!(f, "{}", proxy)
6068 }
6069 }
6070 #[doc = "JPEG DHTMem tables"]
6071 #[repr(transparent)]
6072 #[derive(Copy, Clone, Eq, PartialEq)]
6073 pub struct Dhtmem80(pub u32);
6074 impl Dhtmem80 {
6075 #[doc = "DHTMem RAM"]
6076 #[inline(always)]
6077 pub const fn dhtmem_ram(&self) -> u32 {
6078 let val = (self.0 >> 0usize) & 0xffff_ffff;
6079 val as u32
6080 }
6081 #[doc = "DHTMem RAM"]
6082 #[inline(always)]
6083 pub fn set_dhtmem_ram(&mut self, val: u32) {
6084 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6085 }
6086 }
6087 impl Default for Dhtmem80 {
6088 #[inline(always)]
6089 fn default() -> Dhtmem80 {
6090 Dhtmem80(0)
6091 }
6092 }
6093 impl core::fmt::Debug for Dhtmem80 {
6094 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6095 f.debug_struct("Dhtmem80")
6096 .field("dhtmem_ram", &self.dhtmem_ram())
6097 .finish()
6098 }
6099 }
6100 #[cfg(feature = "defmt")]
6101 impl defmt::Format for Dhtmem80 {
6102 fn format(&self, f: defmt::Formatter) {
6103 #[derive(defmt :: Format)]
6104 struct Dhtmem80 {
6105 dhtmem_ram: u32,
6106 }
6107 let proxy = Dhtmem80 {
6108 dhtmem_ram: self.dhtmem_ram(),
6109 };
6110 defmt::write!(f, "{}", proxy)
6111 }
6112 }
6113 #[doc = "JPEG DHTMem tables"]
6114 #[repr(transparent)]
6115 #[derive(Copy, Clone, Eq, PartialEq)]
6116 pub struct Dhtmem81(pub u32);
6117 impl Dhtmem81 {
6118 #[doc = "DHTMem RAM"]
6119 #[inline(always)]
6120 pub const fn dhtmem_ram(&self) -> u32 {
6121 let val = (self.0 >> 0usize) & 0xffff_ffff;
6122 val as u32
6123 }
6124 #[doc = "DHTMem RAM"]
6125 #[inline(always)]
6126 pub fn set_dhtmem_ram(&mut self, val: u32) {
6127 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6128 }
6129 }
6130 impl Default for Dhtmem81 {
6131 #[inline(always)]
6132 fn default() -> Dhtmem81 {
6133 Dhtmem81(0)
6134 }
6135 }
6136 impl core::fmt::Debug for Dhtmem81 {
6137 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6138 f.debug_struct("Dhtmem81")
6139 .field("dhtmem_ram", &self.dhtmem_ram())
6140 .finish()
6141 }
6142 }
6143 #[cfg(feature = "defmt")]
6144 impl defmt::Format for Dhtmem81 {
6145 fn format(&self, f: defmt::Formatter) {
6146 #[derive(defmt :: Format)]
6147 struct Dhtmem81 {
6148 dhtmem_ram: u32,
6149 }
6150 let proxy = Dhtmem81 {
6151 dhtmem_ram: self.dhtmem_ram(),
6152 };
6153 defmt::write!(f, "{}", proxy)
6154 }
6155 }
6156 #[doc = "JPEG DHTMem tables"]
6157 #[repr(transparent)]
6158 #[derive(Copy, Clone, Eq, PartialEq)]
6159 pub struct Dhtmem82(pub u32);
6160 impl Dhtmem82 {
6161 #[doc = "DHTMem RAM"]
6162 #[inline(always)]
6163 pub const fn dhtmem_ram(&self) -> u32 {
6164 let val = (self.0 >> 0usize) & 0xffff_ffff;
6165 val as u32
6166 }
6167 #[doc = "DHTMem RAM"]
6168 #[inline(always)]
6169 pub fn set_dhtmem_ram(&mut self, val: u32) {
6170 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6171 }
6172 }
6173 impl Default for Dhtmem82 {
6174 #[inline(always)]
6175 fn default() -> Dhtmem82 {
6176 Dhtmem82(0)
6177 }
6178 }
6179 impl core::fmt::Debug for Dhtmem82 {
6180 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6181 f.debug_struct("Dhtmem82")
6182 .field("dhtmem_ram", &self.dhtmem_ram())
6183 .finish()
6184 }
6185 }
6186 #[cfg(feature = "defmt")]
6187 impl defmt::Format for Dhtmem82 {
6188 fn format(&self, f: defmt::Formatter) {
6189 #[derive(defmt :: Format)]
6190 struct Dhtmem82 {
6191 dhtmem_ram: u32,
6192 }
6193 let proxy = Dhtmem82 {
6194 dhtmem_ram: self.dhtmem_ram(),
6195 };
6196 defmt::write!(f, "{}", proxy)
6197 }
6198 }
6199 #[doc = "JPEG DHTMem tables"]
6200 #[repr(transparent)]
6201 #[derive(Copy, Clone, Eq, PartialEq)]
6202 pub struct Dhtmem83(pub u32);
6203 impl Dhtmem83 {
6204 #[doc = "DHTMem RAM"]
6205 #[inline(always)]
6206 pub const fn dhtmem_ram(&self) -> u32 {
6207 let val = (self.0 >> 0usize) & 0xffff_ffff;
6208 val as u32
6209 }
6210 #[doc = "DHTMem RAM"]
6211 #[inline(always)]
6212 pub fn set_dhtmem_ram(&mut self, val: u32) {
6213 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6214 }
6215 }
6216 impl Default for Dhtmem83 {
6217 #[inline(always)]
6218 fn default() -> Dhtmem83 {
6219 Dhtmem83(0)
6220 }
6221 }
6222 impl core::fmt::Debug for Dhtmem83 {
6223 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6224 f.debug_struct("Dhtmem83")
6225 .field("dhtmem_ram", &self.dhtmem_ram())
6226 .finish()
6227 }
6228 }
6229 #[cfg(feature = "defmt")]
6230 impl defmt::Format for Dhtmem83 {
6231 fn format(&self, f: defmt::Formatter) {
6232 #[derive(defmt :: Format)]
6233 struct Dhtmem83 {
6234 dhtmem_ram: u32,
6235 }
6236 let proxy = Dhtmem83 {
6237 dhtmem_ram: self.dhtmem_ram(),
6238 };
6239 defmt::write!(f, "{}", proxy)
6240 }
6241 }
6242 #[doc = "JPEG DHTMem tables"]
6243 #[repr(transparent)]
6244 #[derive(Copy, Clone, Eq, PartialEq)]
6245 pub struct Dhtmem84(pub u32);
6246 impl Dhtmem84 {
6247 #[doc = "DHTMem RAM"]
6248 #[inline(always)]
6249 pub const fn dhtmem_ram(&self) -> u32 {
6250 let val = (self.0 >> 0usize) & 0xffff_ffff;
6251 val as u32
6252 }
6253 #[doc = "DHTMem RAM"]
6254 #[inline(always)]
6255 pub fn set_dhtmem_ram(&mut self, val: u32) {
6256 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6257 }
6258 }
6259 impl Default for Dhtmem84 {
6260 #[inline(always)]
6261 fn default() -> Dhtmem84 {
6262 Dhtmem84(0)
6263 }
6264 }
6265 impl core::fmt::Debug for Dhtmem84 {
6266 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6267 f.debug_struct("Dhtmem84")
6268 .field("dhtmem_ram", &self.dhtmem_ram())
6269 .finish()
6270 }
6271 }
6272 #[cfg(feature = "defmt")]
6273 impl defmt::Format for Dhtmem84 {
6274 fn format(&self, f: defmt::Formatter) {
6275 #[derive(defmt :: Format)]
6276 struct Dhtmem84 {
6277 dhtmem_ram: u32,
6278 }
6279 let proxy = Dhtmem84 {
6280 dhtmem_ram: self.dhtmem_ram(),
6281 };
6282 defmt::write!(f, "{}", proxy)
6283 }
6284 }
6285 #[doc = "JPEG DHTMem tables"]
6286 #[repr(transparent)]
6287 #[derive(Copy, Clone, Eq, PartialEq)]
6288 pub struct Dhtmem85(pub u32);
6289 impl Dhtmem85 {
6290 #[doc = "DHTMem RAM"]
6291 #[inline(always)]
6292 pub const fn dhtmem_ram(&self) -> u32 {
6293 let val = (self.0 >> 0usize) & 0xffff_ffff;
6294 val as u32
6295 }
6296 #[doc = "DHTMem RAM"]
6297 #[inline(always)]
6298 pub fn set_dhtmem_ram(&mut self, val: u32) {
6299 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6300 }
6301 }
6302 impl Default for Dhtmem85 {
6303 #[inline(always)]
6304 fn default() -> Dhtmem85 {
6305 Dhtmem85(0)
6306 }
6307 }
6308 impl core::fmt::Debug for Dhtmem85 {
6309 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6310 f.debug_struct("Dhtmem85")
6311 .field("dhtmem_ram", &self.dhtmem_ram())
6312 .finish()
6313 }
6314 }
6315 #[cfg(feature = "defmt")]
6316 impl defmt::Format for Dhtmem85 {
6317 fn format(&self, f: defmt::Formatter) {
6318 #[derive(defmt :: Format)]
6319 struct Dhtmem85 {
6320 dhtmem_ram: u32,
6321 }
6322 let proxy = Dhtmem85 {
6323 dhtmem_ram: self.dhtmem_ram(),
6324 };
6325 defmt::write!(f, "{}", proxy)
6326 }
6327 }
6328 #[doc = "JPEG DHTMem tables"]
6329 #[repr(transparent)]
6330 #[derive(Copy, Clone, Eq, PartialEq)]
6331 pub struct Dhtmem86(pub u32);
6332 impl Dhtmem86 {
6333 #[doc = "DHTMem RAM"]
6334 #[inline(always)]
6335 pub const fn dhtmem_ram(&self) -> u32 {
6336 let val = (self.0 >> 0usize) & 0xffff_ffff;
6337 val as u32
6338 }
6339 #[doc = "DHTMem RAM"]
6340 #[inline(always)]
6341 pub fn set_dhtmem_ram(&mut self, val: u32) {
6342 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6343 }
6344 }
6345 impl Default for Dhtmem86 {
6346 #[inline(always)]
6347 fn default() -> Dhtmem86 {
6348 Dhtmem86(0)
6349 }
6350 }
6351 impl core::fmt::Debug for Dhtmem86 {
6352 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6353 f.debug_struct("Dhtmem86")
6354 .field("dhtmem_ram", &self.dhtmem_ram())
6355 .finish()
6356 }
6357 }
6358 #[cfg(feature = "defmt")]
6359 impl defmt::Format for Dhtmem86 {
6360 fn format(&self, f: defmt::Formatter) {
6361 #[derive(defmt :: Format)]
6362 struct Dhtmem86 {
6363 dhtmem_ram: u32,
6364 }
6365 let proxy = Dhtmem86 {
6366 dhtmem_ram: self.dhtmem_ram(),
6367 };
6368 defmt::write!(f, "{}", proxy)
6369 }
6370 }
6371 #[doc = "JPEG DHTMem tables"]
6372 #[repr(transparent)]
6373 #[derive(Copy, Clone, Eq, PartialEq)]
6374 pub struct Dhtmem87(pub u32);
6375 impl Dhtmem87 {
6376 #[doc = "DHTMem RAM"]
6377 #[inline(always)]
6378 pub const fn dhtmem_ram(&self) -> u32 {
6379 let val = (self.0 >> 0usize) & 0xffff_ffff;
6380 val as u32
6381 }
6382 #[doc = "DHTMem RAM"]
6383 #[inline(always)]
6384 pub fn set_dhtmem_ram(&mut self, val: u32) {
6385 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6386 }
6387 }
6388 impl Default for Dhtmem87 {
6389 #[inline(always)]
6390 fn default() -> Dhtmem87 {
6391 Dhtmem87(0)
6392 }
6393 }
6394 impl core::fmt::Debug for Dhtmem87 {
6395 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6396 f.debug_struct("Dhtmem87")
6397 .field("dhtmem_ram", &self.dhtmem_ram())
6398 .finish()
6399 }
6400 }
6401 #[cfg(feature = "defmt")]
6402 impl defmt::Format for Dhtmem87 {
6403 fn format(&self, f: defmt::Formatter) {
6404 #[derive(defmt :: Format)]
6405 struct Dhtmem87 {
6406 dhtmem_ram: u32,
6407 }
6408 let proxy = Dhtmem87 {
6409 dhtmem_ram: self.dhtmem_ram(),
6410 };
6411 defmt::write!(f, "{}", proxy)
6412 }
6413 }
6414 #[doc = "JPEG DHTMem tables"]
6415 #[repr(transparent)]
6416 #[derive(Copy, Clone, Eq, PartialEq)]
6417 pub struct Dhtmem88(pub u32);
6418 impl Dhtmem88 {
6419 #[doc = "DHTMem RAM"]
6420 #[inline(always)]
6421 pub const fn dhtmem_ram(&self) -> u32 {
6422 let val = (self.0 >> 0usize) & 0xffff_ffff;
6423 val as u32
6424 }
6425 #[doc = "DHTMem RAM"]
6426 #[inline(always)]
6427 pub fn set_dhtmem_ram(&mut self, val: u32) {
6428 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6429 }
6430 }
6431 impl Default for Dhtmem88 {
6432 #[inline(always)]
6433 fn default() -> Dhtmem88 {
6434 Dhtmem88(0)
6435 }
6436 }
6437 impl core::fmt::Debug for Dhtmem88 {
6438 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6439 f.debug_struct("Dhtmem88")
6440 .field("dhtmem_ram", &self.dhtmem_ram())
6441 .finish()
6442 }
6443 }
6444 #[cfg(feature = "defmt")]
6445 impl defmt::Format for Dhtmem88 {
6446 fn format(&self, f: defmt::Formatter) {
6447 #[derive(defmt :: Format)]
6448 struct Dhtmem88 {
6449 dhtmem_ram: u32,
6450 }
6451 let proxy = Dhtmem88 {
6452 dhtmem_ram: self.dhtmem_ram(),
6453 };
6454 defmt::write!(f, "{}", proxy)
6455 }
6456 }
6457 #[doc = "JPEG DHTMem tables"]
6458 #[repr(transparent)]
6459 #[derive(Copy, Clone, Eq, PartialEq)]
6460 pub struct Dhtmem89(pub u32);
6461 impl Dhtmem89 {
6462 #[doc = "DHTMem RAM"]
6463 #[inline(always)]
6464 pub const fn dhtmem_ram(&self) -> u32 {
6465 let val = (self.0 >> 0usize) & 0xffff_ffff;
6466 val as u32
6467 }
6468 #[doc = "DHTMem RAM"]
6469 #[inline(always)]
6470 pub fn set_dhtmem_ram(&mut self, val: u32) {
6471 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6472 }
6473 }
6474 impl Default for Dhtmem89 {
6475 #[inline(always)]
6476 fn default() -> Dhtmem89 {
6477 Dhtmem89(0)
6478 }
6479 }
6480 impl core::fmt::Debug for Dhtmem89 {
6481 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6482 f.debug_struct("Dhtmem89")
6483 .field("dhtmem_ram", &self.dhtmem_ram())
6484 .finish()
6485 }
6486 }
6487 #[cfg(feature = "defmt")]
6488 impl defmt::Format for Dhtmem89 {
6489 fn format(&self, f: defmt::Formatter) {
6490 #[derive(defmt :: Format)]
6491 struct Dhtmem89 {
6492 dhtmem_ram: u32,
6493 }
6494 let proxy = Dhtmem89 {
6495 dhtmem_ram: self.dhtmem_ram(),
6496 };
6497 defmt::write!(f, "{}", proxy)
6498 }
6499 }
6500 #[doc = "JPEG DHTMem tables"]
6501 #[repr(transparent)]
6502 #[derive(Copy, Clone, Eq, PartialEq)]
6503 pub struct Dhtmem9(pub u32);
6504 impl Dhtmem9 {
6505 #[doc = "DHTMem RAM"]
6506 #[inline(always)]
6507 pub const fn dhtmem_ram(&self) -> u32 {
6508 let val = (self.0 >> 0usize) & 0xffff_ffff;
6509 val as u32
6510 }
6511 #[doc = "DHTMem RAM"]
6512 #[inline(always)]
6513 pub fn set_dhtmem_ram(&mut self, val: u32) {
6514 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6515 }
6516 }
6517 impl Default for Dhtmem9 {
6518 #[inline(always)]
6519 fn default() -> Dhtmem9 {
6520 Dhtmem9(0)
6521 }
6522 }
6523 impl core::fmt::Debug for Dhtmem9 {
6524 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6525 f.debug_struct("Dhtmem9")
6526 .field("dhtmem_ram", &self.dhtmem_ram())
6527 .finish()
6528 }
6529 }
6530 #[cfg(feature = "defmt")]
6531 impl defmt::Format for Dhtmem9 {
6532 fn format(&self, f: defmt::Formatter) {
6533 #[derive(defmt :: Format)]
6534 struct Dhtmem9 {
6535 dhtmem_ram: u32,
6536 }
6537 let proxy = Dhtmem9 {
6538 dhtmem_ram: self.dhtmem_ram(),
6539 };
6540 defmt::write!(f, "{}", proxy)
6541 }
6542 }
6543 #[doc = "JPEG DHTMem tables"]
6544 #[repr(transparent)]
6545 #[derive(Copy, Clone, Eq, PartialEq)]
6546 pub struct Dhtmem90(pub u32);
6547 impl Dhtmem90 {
6548 #[doc = "DHTMem RAM"]
6549 #[inline(always)]
6550 pub const fn dhtmem_ram(&self) -> u32 {
6551 let val = (self.0 >> 0usize) & 0xffff_ffff;
6552 val as u32
6553 }
6554 #[doc = "DHTMem RAM"]
6555 #[inline(always)]
6556 pub fn set_dhtmem_ram(&mut self, val: u32) {
6557 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6558 }
6559 }
6560 impl Default for Dhtmem90 {
6561 #[inline(always)]
6562 fn default() -> Dhtmem90 {
6563 Dhtmem90(0)
6564 }
6565 }
6566 impl core::fmt::Debug for Dhtmem90 {
6567 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6568 f.debug_struct("Dhtmem90")
6569 .field("dhtmem_ram", &self.dhtmem_ram())
6570 .finish()
6571 }
6572 }
6573 #[cfg(feature = "defmt")]
6574 impl defmt::Format for Dhtmem90 {
6575 fn format(&self, f: defmt::Formatter) {
6576 #[derive(defmt :: Format)]
6577 struct Dhtmem90 {
6578 dhtmem_ram: u32,
6579 }
6580 let proxy = Dhtmem90 {
6581 dhtmem_ram: self.dhtmem_ram(),
6582 };
6583 defmt::write!(f, "{}", proxy)
6584 }
6585 }
6586 #[doc = "JPEG DHTMem tables"]
6587 #[repr(transparent)]
6588 #[derive(Copy, Clone, Eq, PartialEq)]
6589 pub struct Dhtmem91(pub u32);
6590 impl Dhtmem91 {
6591 #[doc = "DHTMem RAM"]
6592 #[inline(always)]
6593 pub const fn dhtmem_ram(&self) -> u32 {
6594 let val = (self.0 >> 0usize) & 0xffff_ffff;
6595 val as u32
6596 }
6597 #[doc = "DHTMem RAM"]
6598 #[inline(always)]
6599 pub fn set_dhtmem_ram(&mut self, val: u32) {
6600 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6601 }
6602 }
6603 impl Default for Dhtmem91 {
6604 #[inline(always)]
6605 fn default() -> Dhtmem91 {
6606 Dhtmem91(0)
6607 }
6608 }
6609 impl core::fmt::Debug for Dhtmem91 {
6610 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6611 f.debug_struct("Dhtmem91")
6612 .field("dhtmem_ram", &self.dhtmem_ram())
6613 .finish()
6614 }
6615 }
6616 #[cfg(feature = "defmt")]
6617 impl defmt::Format for Dhtmem91 {
6618 fn format(&self, f: defmt::Formatter) {
6619 #[derive(defmt :: Format)]
6620 struct Dhtmem91 {
6621 dhtmem_ram: u32,
6622 }
6623 let proxy = Dhtmem91 {
6624 dhtmem_ram: self.dhtmem_ram(),
6625 };
6626 defmt::write!(f, "{}", proxy)
6627 }
6628 }
6629 #[doc = "JPEG DHTMem tables"]
6630 #[repr(transparent)]
6631 #[derive(Copy, Clone, Eq, PartialEq)]
6632 pub struct Dhtmem92(pub u32);
6633 impl Dhtmem92 {
6634 #[doc = "DHTMem RAM"]
6635 #[inline(always)]
6636 pub const fn dhtmem_ram(&self) -> u32 {
6637 let val = (self.0 >> 0usize) & 0xffff_ffff;
6638 val as u32
6639 }
6640 #[doc = "DHTMem RAM"]
6641 #[inline(always)]
6642 pub fn set_dhtmem_ram(&mut self, val: u32) {
6643 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6644 }
6645 }
6646 impl Default for Dhtmem92 {
6647 #[inline(always)]
6648 fn default() -> Dhtmem92 {
6649 Dhtmem92(0)
6650 }
6651 }
6652 impl core::fmt::Debug for Dhtmem92 {
6653 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6654 f.debug_struct("Dhtmem92")
6655 .field("dhtmem_ram", &self.dhtmem_ram())
6656 .finish()
6657 }
6658 }
6659 #[cfg(feature = "defmt")]
6660 impl defmt::Format for Dhtmem92 {
6661 fn format(&self, f: defmt::Formatter) {
6662 #[derive(defmt :: Format)]
6663 struct Dhtmem92 {
6664 dhtmem_ram: u32,
6665 }
6666 let proxy = Dhtmem92 {
6667 dhtmem_ram: self.dhtmem_ram(),
6668 };
6669 defmt::write!(f, "{}", proxy)
6670 }
6671 }
6672 #[doc = "JPEG DHTMem tables"]
6673 #[repr(transparent)]
6674 #[derive(Copy, Clone, Eq, PartialEq)]
6675 pub struct Dhtmem93(pub u32);
6676 impl Dhtmem93 {
6677 #[doc = "DHTMem RAM"]
6678 #[inline(always)]
6679 pub const fn dhtmem_ram(&self) -> u32 {
6680 let val = (self.0 >> 0usize) & 0xffff_ffff;
6681 val as u32
6682 }
6683 #[doc = "DHTMem RAM"]
6684 #[inline(always)]
6685 pub fn set_dhtmem_ram(&mut self, val: u32) {
6686 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6687 }
6688 }
6689 impl Default for Dhtmem93 {
6690 #[inline(always)]
6691 fn default() -> Dhtmem93 {
6692 Dhtmem93(0)
6693 }
6694 }
6695 impl core::fmt::Debug for Dhtmem93 {
6696 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6697 f.debug_struct("Dhtmem93")
6698 .field("dhtmem_ram", &self.dhtmem_ram())
6699 .finish()
6700 }
6701 }
6702 #[cfg(feature = "defmt")]
6703 impl defmt::Format for Dhtmem93 {
6704 fn format(&self, f: defmt::Formatter) {
6705 #[derive(defmt :: Format)]
6706 struct Dhtmem93 {
6707 dhtmem_ram: u32,
6708 }
6709 let proxy = Dhtmem93 {
6710 dhtmem_ram: self.dhtmem_ram(),
6711 };
6712 defmt::write!(f, "{}", proxy)
6713 }
6714 }
6715 #[doc = "JPEG DHTMem tables"]
6716 #[repr(transparent)]
6717 #[derive(Copy, Clone, Eq, PartialEq)]
6718 pub struct Dhtmem94(pub u32);
6719 impl Dhtmem94 {
6720 #[doc = "DHTMem RAM"]
6721 #[inline(always)]
6722 pub const fn dhtmem_ram(&self) -> u32 {
6723 let val = (self.0 >> 0usize) & 0xffff_ffff;
6724 val as u32
6725 }
6726 #[doc = "DHTMem RAM"]
6727 #[inline(always)]
6728 pub fn set_dhtmem_ram(&mut self, val: u32) {
6729 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6730 }
6731 }
6732 impl Default for Dhtmem94 {
6733 #[inline(always)]
6734 fn default() -> Dhtmem94 {
6735 Dhtmem94(0)
6736 }
6737 }
6738 impl core::fmt::Debug for Dhtmem94 {
6739 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6740 f.debug_struct("Dhtmem94")
6741 .field("dhtmem_ram", &self.dhtmem_ram())
6742 .finish()
6743 }
6744 }
6745 #[cfg(feature = "defmt")]
6746 impl defmt::Format for Dhtmem94 {
6747 fn format(&self, f: defmt::Formatter) {
6748 #[derive(defmt :: Format)]
6749 struct Dhtmem94 {
6750 dhtmem_ram: u32,
6751 }
6752 let proxy = Dhtmem94 {
6753 dhtmem_ram: self.dhtmem_ram(),
6754 };
6755 defmt::write!(f, "{}", proxy)
6756 }
6757 }
6758 #[doc = "JPEG DHTMem tables"]
6759 #[repr(transparent)]
6760 #[derive(Copy, Clone, Eq, PartialEq)]
6761 pub struct Dhtmem95(pub u32);
6762 impl Dhtmem95 {
6763 #[doc = "DHTMem RAM"]
6764 #[inline(always)]
6765 pub const fn dhtmem_ram(&self) -> u32 {
6766 let val = (self.0 >> 0usize) & 0xffff_ffff;
6767 val as u32
6768 }
6769 #[doc = "DHTMem RAM"]
6770 #[inline(always)]
6771 pub fn set_dhtmem_ram(&mut self, val: u32) {
6772 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6773 }
6774 }
6775 impl Default for Dhtmem95 {
6776 #[inline(always)]
6777 fn default() -> Dhtmem95 {
6778 Dhtmem95(0)
6779 }
6780 }
6781 impl core::fmt::Debug for Dhtmem95 {
6782 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6783 f.debug_struct("Dhtmem95")
6784 .field("dhtmem_ram", &self.dhtmem_ram())
6785 .finish()
6786 }
6787 }
6788 #[cfg(feature = "defmt")]
6789 impl defmt::Format for Dhtmem95 {
6790 fn format(&self, f: defmt::Formatter) {
6791 #[derive(defmt :: Format)]
6792 struct Dhtmem95 {
6793 dhtmem_ram: u32,
6794 }
6795 let proxy = Dhtmem95 {
6796 dhtmem_ram: self.dhtmem_ram(),
6797 };
6798 defmt::write!(f, "{}", proxy)
6799 }
6800 }
6801 #[doc = "JPEG DHTMem tables"]
6802 #[repr(transparent)]
6803 #[derive(Copy, Clone, Eq, PartialEq)]
6804 pub struct Dhtmem96(pub u32);
6805 impl Dhtmem96 {
6806 #[doc = "DHTMem RAM"]
6807 #[inline(always)]
6808 pub const fn dhtmem_ram(&self) -> u32 {
6809 let val = (self.0 >> 0usize) & 0xffff_ffff;
6810 val as u32
6811 }
6812 #[doc = "DHTMem RAM"]
6813 #[inline(always)]
6814 pub fn set_dhtmem_ram(&mut self, val: u32) {
6815 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6816 }
6817 }
6818 impl Default for Dhtmem96 {
6819 #[inline(always)]
6820 fn default() -> Dhtmem96 {
6821 Dhtmem96(0)
6822 }
6823 }
6824 impl core::fmt::Debug for Dhtmem96 {
6825 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6826 f.debug_struct("Dhtmem96")
6827 .field("dhtmem_ram", &self.dhtmem_ram())
6828 .finish()
6829 }
6830 }
6831 #[cfg(feature = "defmt")]
6832 impl defmt::Format for Dhtmem96 {
6833 fn format(&self, f: defmt::Formatter) {
6834 #[derive(defmt :: Format)]
6835 struct Dhtmem96 {
6836 dhtmem_ram: u32,
6837 }
6838 let proxy = Dhtmem96 {
6839 dhtmem_ram: self.dhtmem_ram(),
6840 };
6841 defmt::write!(f, "{}", proxy)
6842 }
6843 }
6844 #[doc = "JPEG DHTMem tables"]
6845 #[repr(transparent)]
6846 #[derive(Copy, Clone, Eq, PartialEq)]
6847 pub struct Dhtmem97(pub u32);
6848 impl Dhtmem97 {
6849 #[doc = "DHTMem RAM"]
6850 #[inline(always)]
6851 pub const fn dhtmem_ram(&self) -> u32 {
6852 let val = (self.0 >> 0usize) & 0xffff_ffff;
6853 val as u32
6854 }
6855 #[doc = "DHTMem RAM"]
6856 #[inline(always)]
6857 pub fn set_dhtmem_ram(&mut self, val: u32) {
6858 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6859 }
6860 }
6861 impl Default for Dhtmem97 {
6862 #[inline(always)]
6863 fn default() -> Dhtmem97 {
6864 Dhtmem97(0)
6865 }
6866 }
6867 impl core::fmt::Debug for Dhtmem97 {
6868 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6869 f.debug_struct("Dhtmem97")
6870 .field("dhtmem_ram", &self.dhtmem_ram())
6871 .finish()
6872 }
6873 }
6874 #[cfg(feature = "defmt")]
6875 impl defmt::Format for Dhtmem97 {
6876 fn format(&self, f: defmt::Formatter) {
6877 #[derive(defmt :: Format)]
6878 struct Dhtmem97 {
6879 dhtmem_ram: u32,
6880 }
6881 let proxy = Dhtmem97 {
6882 dhtmem_ram: self.dhtmem_ram(),
6883 };
6884 defmt::write!(f, "{}", proxy)
6885 }
6886 }
6887 #[doc = "JPEG DHTMem tables"]
6888 #[repr(transparent)]
6889 #[derive(Copy, Clone, Eq, PartialEq)]
6890 pub struct Dhtmem98(pub u32);
6891 impl Dhtmem98 {
6892 #[doc = "DHTMem RAM"]
6893 #[inline(always)]
6894 pub const fn dhtmem_ram(&self) -> u32 {
6895 let val = (self.0 >> 0usize) & 0xffff_ffff;
6896 val as u32
6897 }
6898 #[doc = "DHTMem RAM"]
6899 #[inline(always)]
6900 pub fn set_dhtmem_ram(&mut self, val: u32) {
6901 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6902 }
6903 }
6904 impl Default for Dhtmem98 {
6905 #[inline(always)]
6906 fn default() -> Dhtmem98 {
6907 Dhtmem98(0)
6908 }
6909 }
6910 impl core::fmt::Debug for Dhtmem98 {
6911 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6912 f.debug_struct("Dhtmem98")
6913 .field("dhtmem_ram", &self.dhtmem_ram())
6914 .finish()
6915 }
6916 }
6917 #[cfg(feature = "defmt")]
6918 impl defmt::Format for Dhtmem98 {
6919 fn format(&self, f: defmt::Formatter) {
6920 #[derive(defmt :: Format)]
6921 struct Dhtmem98 {
6922 dhtmem_ram: u32,
6923 }
6924 let proxy = Dhtmem98 {
6925 dhtmem_ram: self.dhtmem_ram(),
6926 };
6927 defmt::write!(f, "{}", proxy)
6928 }
6929 }
6930 #[doc = "JPEG DHTMem tables"]
6931 #[repr(transparent)]
6932 #[derive(Copy, Clone, Eq, PartialEq)]
6933 pub struct Dhtmem99(pub u32);
6934 impl Dhtmem99 {
6935 #[doc = "DHTMem RAM"]
6936 #[inline(always)]
6937 pub const fn dhtmem_ram(&self) -> u32 {
6938 let val = (self.0 >> 0usize) & 0xffff_ffff;
6939 val as u32
6940 }
6941 #[doc = "DHTMem RAM"]
6942 #[inline(always)]
6943 pub fn set_dhtmem_ram(&mut self, val: u32) {
6944 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
6945 }
6946 }
6947 impl Default for Dhtmem99 {
6948 #[inline(always)]
6949 fn default() -> Dhtmem99 {
6950 Dhtmem99(0)
6951 }
6952 }
6953 impl core::fmt::Debug for Dhtmem99 {
6954 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
6955 f.debug_struct("Dhtmem99")
6956 .field("dhtmem_ram", &self.dhtmem_ram())
6957 .finish()
6958 }
6959 }
6960 #[cfg(feature = "defmt")]
6961 impl defmt::Format for Dhtmem99 {
6962 fn format(&self, f: defmt::Formatter) {
6963 #[derive(defmt :: Format)]
6964 struct Dhtmem99 {
6965 dhtmem_ram: u32,
6966 }
6967 let proxy = Dhtmem99 {
6968 dhtmem_ram: self.dhtmem_ram(),
6969 };
6970 defmt::write!(f, "{}", proxy)
6971 }
6972 }
6973 #[doc = "JPEG HuffSymb tables"]
6974 #[repr(transparent)]
6975 #[derive(Copy, Clone, Eq, PartialEq)]
6976 pub struct Huffbase0(pub u32);
6977 impl Huffbase0 {
6978 #[doc = "HuffBase RAM"]
6979 #[inline(always)]
6980 pub const fn huff_base_ram_0(&self) -> u16 {
6981 let val = (self.0 >> 0usize) & 0x01ff;
6982 val as u16
6983 }
6984 #[doc = "HuffBase RAM"]
6985 #[inline(always)]
6986 pub fn set_huff_base_ram_0(&mut self, val: u16) {
6987 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
6988 }
6989 #[doc = "HuffBase RAM"]
6990 #[inline(always)]
6991 pub const fn huff_base_ram_1(&self) -> u16 {
6992 let val = (self.0 >> 16usize) & 0x01ff;
6993 val as u16
6994 }
6995 #[doc = "HuffBase RAM"]
6996 #[inline(always)]
6997 pub fn set_huff_base_ram_1(&mut self, val: u16) {
6998 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
6999 }
7000 }
7001 impl Default for Huffbase0 {
7002 #[inline(always)]
7003 fn default() -> Huffbase0 {
7004 Huffbase0(0)
7005 }
7006 }
7007 impl core::fmt::Debug for Huffbase0 {
7008 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7009 f.debug_struct("Huffbase0")
7010 .field("huff_base_ram_0", &self.huff_base_ram_0())
7011 .field("huff_base_ram_1", &self.huff_base_ram_1())
7012 .finish()
7013 }
7014 }
7015 #[cfg(feature = "defmt")]
7016 impl defmt::Format for Huffbase0 {
7017 fn format(&self, f: defmt::Formatter) {
7018 #[derive(defmt :: Format)]
7019 struct Huffbase0 {
7020 huff_base_ram_0: u16,
7021 huff_base_ram_1: u16,
7022 }
7023 let proxy = Huffbase0 {
7024 huff_base_ram_0: self.huff_base_ram_0(),
7025 huff_base_ram_1: self.huff_base_ram_1(),
7026 };
7027 defmt::write!(f, "{}", proxy)
7028 }
7029 }
7030 #[doc = "JPEG HuffSymb tables"]
7031 #[repr(transparent)]
7032 #[derive(Copy, Clone, Eq, PartialEq)]
7033 pub struct Huffbase1(pub u32);
7034 impl Huffbase1 {
7035 #[doc = "HuffBase RAM"]
7036 #[inline(always)]
7037 pub const fn huff_base_ram_0(&self) -> u16 {
7038 let val = (self.0 >> 0usize) & 0x01ff;
7039 val as u16
7040 }
7041 #[doc = "HuffBase RAM"]
7042 #[inline(always)]
7043 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7044 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7045 }
7046 #[doc = "HuffBase RAM"]
7047 #[inline(always)]
7048 pub const fn huff_base_ram_1(&self) -> u16 {
7049 let val = (self.0 >> 16usize) & 0x01ff;
7050 val as u16
7051 }
7052 #[doc = "HuffBase RAM"]
7053 #[inline(always)]
7054 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7055 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7056 }
7057 }
7058 impl Default for Huffbase1 {
7059 #[inline(always)]
7060 fn default() -> Huffbase1 {
7061 Huffbase1(0)
7062 }
7063 }
7064 impl core::fmt::Debug for Huffbase1 {
7065 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7066 f.debug_struct("Huffbase1")
7067 .field("huff_base_ram_0", &self.huff_base_ram_0())
7068 .field("huff_base_ram_1", &self.huff_base_ram_1())
7069 .finish()
7070 }
7071 }
7072 #[cfg(feature = "defmt")]
7073 impl defmt::Format for Huffbase1 {
7074 fn format(&self, f: defmt::Formatter) {
7075 #[derive(defmt :: Format)]
7076 struct Huffbase1 {
7077 huff_base_ram_0: u16,
7078 huff_base_ram_1: u16,
7079 }
7080 let proxy = Huffbase1 {
7081 huff_base_ram_0: self.huff_base_ram_0(),
7082 huff_base_ram_1: self.huff_base_ram_1(),
7083 };
7084 defmt::write!(f, "{}", proxy)
7085 }
7086 }
7087 #[doc = "JPEG HuffSymb tables"]
7088 #[repr(transparent)]
7089 #[derive(Copy, Clone, Eq, PartialEq)]
7090 pub struct Huffbase10(pub u32);
7091 impl Huffbase10 {
7092 #[doc = "HuffBase RAM"]
7093 #[inline(always)]
7094 pub const fn huff_base_ram_0(&self) -> u16 {
7095 let val = (self.0 >> 0usize) & 0x01ff;
7096 val as u16
7097 }
7098 #[doc = "HuffBase RAM"]
7099 #[inline(always)]
7100 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7101 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7102 }
7103 #[doc = "HuffBase RAM"]
7104 #[inline(always)]
7105 pub const fn huff_base_ram_1(&self) -> u16 {
7106 let val = (self.0 >> 16usize) & 0x01ff;
7107 val as u16
7108 }
7109 #[doc = "HuffBase RAM"]
7110 #[inline(always)]
7111 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7112 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7113 }
7114 }
7115 impl Default for Huffbase10 {
7116 #[inline(always)]
7117 fn default() -> Huffbase10 {
7118 Huffbase10(0)
7119 }
7120 }
7121 impl core::fmt::Debug for Huffbase10 {
7122 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7123 f.debug_struct("Huffbase10")
7124 .field("huff_base_ram_0", &self.huff_base_ram_0())
7125 .field("huff_base_ram_1", &self.huff_base_ram_1())
7126 .finish()
7127 }
7128 }
7129 #[cfg(feature = "defmt")]
7130 impl defmt::Format for Huffbase10 {
7131 fn format(&self, f: defmt::Formatter) {
7132 #[derive(defmt :: Format)]
7133 struct Huffbase10 {
7134 huff_base_ram_0: u16,
7135 huff_base_ram_1: u16,
7136 }
7137 let proxy = Huffbase10 {
7138 huff_base_ram_0: self.huff_base_ram_0(),
7139 huff_base_ram_1: self.huff_base_ram_1(),
7140 };
7141 defmt::write!(f, "{}", proxy)
7142 }
7143 }
7144 #[doc = "JPEG HuffSymb tables"]
7145 #[repr(transparent)]
7146 #[derive(Copy, Clone, Eq, PartialEq)]
7147 pub struct Huffbase11(pub u32);
7148 impl Huffbase11 {
7149 #[doc = "HuffBase RAM"]
7150 #[inline(always)]
7151 pub const fn huff_base_ram_0(&self) -> u16 {
7152 let val = (self.0 >> 0usize) & 0x01ff;
7153 val as u16
7154 }
7155 #[doc = "HuffBase RAM"]
7156 #[inline(always)]
7157 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7158 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7159 }
7160 #[doc = "HuffBase RAM"]
7161 #[inline(always)]
7162 pub const fn huff_base_ram_1(&self) -> u16 {
7163 let val = (self.0 >> 16usize) & 0x01ff;
7164 val as u16
7165 }
7166 #[doc = "HuffBase RAM"]
7167 #[inline(always)]
7168 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7169 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7170 }
7171 }
7172 impl Default for Huffbase11 {
7173 #[inline(always)]
7174 fn default() -> Huffbase11 {
7175 Huffbase11(0)
7176 }
7177 }
7178 impl core::fmt::Debug for Huffbase11 {
7179 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7180 f.debug_struct("Huffbase11")
7181 .field("huff_base_ram_0", &self.huff_base_ram_0())
7182 .field("huff_base_ram_1", &self.huff_base_ram_1())
7183 .finish()
7184 }
7185 }
7186 #[cfg(feature = "defmt")]
7187 impl defmt::Format for Huffbase11 {
7188 fn format(&self, f: defmt::Formatter) {
7189 #[derive(defmt :: Format)]
7190 struct Huffbase11 {
7191 huff_base_ram_0: u16,
7192 huff_base_ram_1: u16,
7193 }
7194 let proxy = Huffbase11 {
7195 huff_base_ram_0: self.huff_base_ram_0(),
7196 huff_base_ram_1: self.huff_base_ram_1(),
7197 };
7198 defmt::write!(f, "{}", proxy)
7199 }
7200 }
7201 #[doc = "JPEG HuffSymb tables"]
7202 #[repr(transparent)]
7203 #[derive(Copy, Clone, Eq, PartialEq)]
7204 pub struct Huffbase12(pub u32);
7205 impl Huffbase12 {
7206 #[doc = "HuffBase RAM"]
7207 #[inline(always)]
7208 pub const fn huff_base_ram_0(&self) -> u16 {
7209 let val = (self.0 >> 0usize) & 0x01ff;
7210 val as u16
7211 }
7212 #[doc = "HuffBase RAM"]
7213 #[inline(always)]
7214 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7215 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7216 }
7217 #[doc = "HuffBase RAM"]
7218 #[inline(always)]
7219 pub const fn huff_base_ram_1(&self) -> u16 {
7220 let val = (self.0 >> 16usize) & 0x01ff;
7221 val as u16
7222 }
7223 #[doc = "HuffBase RAM"]
7224 #[inline(always)]
7225 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7226 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7227 }
7228 }
7229 impl Default for Huffbase12 {
7230 #[inline(always)]
7231 fn default() -> Huffbase12 {
7232 Huffbase12(0)
7233 }
7234 }
7235 impl core::fmt::Debug for Huffbase12 {
7236 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7237 f.debug_struct("Huffbase12")
7238 .field("huff_base_ram_0", &self.huff_base_ram_0())
7239 .field("huff_base_ram_1", &self.huff_base_ram_1())
7240 .finish()
7241 }
7242 }
7243 #[cfg(feature = "defmt")]
7244 impl defmt::Format for Huffbase12 {
7245 fn format(&self, f: defmt::Formatter) {
7246 #[derive(defmt :: Format)]
7247 struct Huffbase12 {
7248 huff_base_ram_0: u16,
7249 huff_base_ram_1: u16,
7250 }
7251 let proxy = Huffbase12 {
7252 huff_base_ram_0: self.huff_base_ram_0(),
7253 huff_base_ram_1: self.huff_base_ram_1(),
7254 };
7255 defmt::write!(f, "{}", proxy)
7256 }
7257 }
7258 #[doc = "JPEG HuffSymb tables"]
7259 #[repr(transparent)]
7260 #[derive(Copy, Clone, Eq, PartialEq)]
7261 pub struct Huffbase13(pub u32);
7262 impl Huffbase13 {
7263 #[doc = "HuffBase RAM"]
7264 #[inline(always)]
7265 pub const fn huff_base_ram_0(&self) -> u16 {
7266 let val = (self.0 >> 0usize) & 0x01ff;
7267 val as u16
7268 }
7269 #[doc = "HuffBase RAM"]
7270 #[inline(always)]
7271 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7272 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7273 }
7274 #[doc = "HuffBase RAM"]
7275 #[inline(always)]
7276 pub const fn huff_base_ram_1(&self) -> u16 {
7277 let val = (self.0 >> 16usize) & 0x01ff;
7278 val as u16
7279 }
7280 #[doc = "HuffBase RAM"]
7281 #[inline(always)]
7282 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7283 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7284 }
7285 }
7286 impl Default for Huffbase13 {
7287 #[inline(always)]
7288 fn default() -> Huffbase13 {
7289 Huffbase13(0)
7290 }
7291 }
7292 impl core::fmt::Debug for Huffbase13 {
7293 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7294 f.debug_struct("Huffbase13")
7295 .field("huff_base_ram_0", &self.huff_base_ram_0())
7296 .field("huff_base_ram_1", &self.huff_base_ram_1())
7297 .finish()
7298 }
7299 }
7300 #[cfg(feature = "defmt")]
7301 impl defmt::Format for Huffbase13 {
7302 fn format(&self, f: defmt::Formatter) {
7303 #[derive(defmt :: Format)]
7304 struct Huffbase13 {
7305 huff_base_ram_0: u16,
7306 huff_base_ram_1: u16,
7307 }
7308 let proxy = Huffbase13 {
7309 huff_base_ram_0: self.huff_base_ram_0(),
7310 huff_base_ram_1: self.huff_base_ram_1(),
7311 };
7312 defmt::write!(f, "{}", proxy)
7313 }
7314 }
7315 #[doc = "JPEG HuffSymb tables"]
7316 #[repr(transparent)]
7317 #[derive(Copy, Clone, Eq, PartialEq)]
7318 pub struct Huffbase14(pub u32);
7319 impl Huffbase14 {
7320 #[doc = "HuffBase RAM"]
7321 #[inline(always)]
7322 pub const fn huff_base_ram_0(&self) -> u16 {
7323 let val = (self.0 >> 0usize) & 0x01ff;
7324 val as u16
7325 }
7326 #[doc = "HuffBase RAM"]
7327 #[inline(always)]
7328 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7329 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7330 }
7331 #[doc = "HuffBase RAM"]
7332 #[inline(always)]
7333 pub const fn huff_base_ram_1(&self) -> u16 {
7334 let val = (self.0 >> 16usize) & 0x01ff;
7335 val as u16
7336 }
7337 #[doc = "HuffBase RAM"]
7338 #[inline(always)]
7339 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7340 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7341 }
7342 }
7343 impl Default for Huffbase14 {
7344 #[inline(always)]
7345 fn default() -> Huffbase14 {
7346 Huffbase14(0)
7347 }
7348 }
7349 impl core::fmt::Debug for Huffbase14 {
7350 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7351 f.debug_struct("Huffbase14")
7352 .field("huff_base_ram_0", &self.huff_base_ram_0())
7353 .field("huff_base_ram_1", &self.huff_base_ram_1())
7354 .finish()
7355 }
7356 }
7357 #[cfg(feature = "defmt")]
7358 impl defmt::Format for Huffbase14 {
7359 fn format(&self, f: defmt::Formatter) {
7360 #[derive(defmt :: Format)]
7361 struct Huffbase14 {
7362 huff_base_ram_0: u16,
7363 huff_base_ram_1: u16,
7364 }
7365 let proxy = Huffbase14 {
7366 huff_base_ram_0: self.huff_base_ram_0(),
7367 huff_base_ram_1: self.huff_base_ram_1(),
7368 };
7369 defmt::write!(f, "{}", proxy)
7370 }
7371 }
7372 #[doc = "JPEG HuffSymb tables"]
7373 #[repr(transparent)]
7374 #[derive(Copy, Clone, Eq, PartialEq)]
7375 pub struct Huffbase15(pub u32);
7376 impl Huffbase15 {
7377 #[doc = "HuffBase RAM"]
7378 #[inline(always)]
7379 pub const fn huff_base_ram_0(&self) -> u16 {
7380 let val = (self.0 >> 0usize) & 0x01ff;
7381 val as u16
7382 }
7383 #[doc = "HuffBase RAM"]
7384 #[inline(always)]
7385 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7386 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7387 }
7388 #[doc = "HuffBase RAM"]
7389 #[inline(always)]
7390 pub const fn huff_base_ram_1(&self) -> u16 {
7391 let val = (self.0 >> 16usize) & 0x01ff;
7392 val as u16
7393 }
7394 #[doc = "HuffBase RAM"]
7395 #[inline(always)]
7396 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7397 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7398 }
7399 }
7400 impl Default for Huffbase15 {
7401 #[inline(always)]
7402 fn default() -> Huffbase15 {
7403 Huffbase15(0)
7404 }
7405 }
7406 impl core::fmt::Debug for Huffbase15 {
7407 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7408 f.debug_struct("Huffbase15")
7409 .field("huff_base_ram_0", &self.huff_base_ram_0())
7410 .field("huff_base_ram_1", &self.huff_base_ram_1())
7411 .finish()
7412 }
7413 }
7414 #[cfg(feature = "defmt")]
7415 impl defmt::Format for Huffbase15 {
7416 fn format(&self, f: defmt::Formatter) {
7417 #[derive(defmt :: Format)]
7418 struct Huffbase15 {
7419 huff_base_ram_0: u16,
7420 huff_base_ram_1: u16,
7421 }
7422 let proxy = Huffbase15 {
7423 huff_base_ram_0: self.huff_base_ram_0(),
7424 huff_base_ram_1: self.huff_base_ram_1(),
7425 };
7426 defmt::write!(f, "{}", proxy)
7427 }
7428 }
7429 #[doc = "JPEG HuffSymb tables"]
7430 #[repr(transparent)]
7431 #[derive(Copy, Clone, Eq, PartialEq)]
7432 pub struct Huffbase16(pub u32);
7433 impl Huffbase16 {
7434 #[doc = "HuffBase RAM"]
7435 #[inline(always)]
7436 pub const fn huff_base_ram_0(&self) -> u16 {
7437 let val = (self.0 >> 0usize) & 0x01ff;
7438 val as u16
7439 }
7440 #[doc = "HuffBase RAM"]
7441 #[inline(always)]
7442 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7443 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7444 }
7445 #[doc = "HuffBase RAM"]
7446 #[inline(always)]
7447 pub const fn huff_base_ram_1(&self) -> u16 {
7448 let val = (self.0 >> 16usize) & 0x01ff;
7449 val as u16
7450 }
7451 #[doc = "HuffBase RAM"]
7452 #[inline(always)]
7453 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7454 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7455 }
7456 }
7457 impl Default for Huffbase16 {
7458 #[inline(always)]
7459 fn default() -> Huffbase16 {
7460 Huffbase16(0)
7461 }
7462 }
7463 impl core::fmt::Debug for Huffbase16 {
7464 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7465 f.debug_struct("Huffbase16")
7466 .field("huff_base_ram_0", &self.huff_base_ram_0())
7467 .field("huff_base_ram_1", &self.huff_base_ram_1())
7468 .finish()
7469 }
7470 }
7471 #[cfg(feature = "defmt")]
7472 impl defmt::Format for Huffbase16 {
7473 fn format(&self, f: defmt::Formatter) {
7474 #[derive(defmt :: Format)]
7475 struct Huffbase16 {
7476 huff_base_ram_0: u16,
7477 huff_base_ram_1: u16,
7478 }
7479 let proxy = Huffbase16 {
7480 huff_base_ram_0: self.huff_base_ram_0(),
7481 huff_base_ram_1: self.huff_base_ram_1(),
7482 };
7483 defmt::write!(f, "{}", proxy)
7484 }
7485 }
7486 #[doc = "JPEG HuffSymb tables"]
7487 #[repr(transparent)]
7488 #[derive(Copy, Clone, Eq, PartialEq)]
7489 pub struct Huffbase17(pub u32);
7490 impl Huffbase17 {
7491 #[doc = "HuffBase RAM"]
7492 #[inline(always)]
7493 pub const fn huff_base_ram_0(&self) -> u16 {
7494 let val = (self.0 >> 0usize) & 0x01ff;
7495 val as u16
7496 }
7497 #[doc = "HuffBase RAM"]
7498 #[inline(always)]
7499 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7500 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7501 }
7502 #[doc = "HuffBase RAM"]
7503 #[inline(always)]
7504 pub const fn huff_base_ram_1(&self) -> u16 {
7505 let val = (self.0 >> 16usize) & 0x01ff;
7506 val as u16
7507 }
7508 #[doc = "HuffBase RAM"]
7509 #[inline(always)]
7510 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7511 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7512 }
7513 }
7514 impl Default for Huffbase17 {
7515 #[inline(always)]
7516 fn default() -> Huffbase17 {
7517 Huffbase17(0)
7518 }
7519 }
7520 impl core::fmt::Debug for Huffbase17 {
7521 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7522 f.debug_struct("Huffbase17")
7523 .field("huff_base_ram_0", &self.huff_base_ram_0())
7524 .field("huff_base_ram_1", &self.huff_base_ram_1())
7525 .finish()
7526 }
7527 }
7528 #[cfg(feature = "defmt")]
7529 impl defmt::Format for Huffbase17 {
7530 fn format(&self, f: defmt::Formatter) {
7531 #[derive(defmt :: Format)]
7532 struct Huffbase17 {
7533 huff_base_ram_0: u16,
7534 huff_base_ram_1: u16,
7535 }
7536 let proxy = Huffbase17 {
7537 huff_base_ram_0: self.huff_base_ram_0(),
7538 huff_base_ram_1: self.huff_base_ram_1(),
7539 };
7540 defmt::write!(f, "{}", proxy)
7541 }
7542 }
7543 #[doc = "JPEG HuffSymb tables"]
7544 #[repr(transparent)]
7545 #[derive(Copy, Clone, Eq, PartialEq)]
7546 pub struct Huffbase18(pub u32);
7547 impl Huffbase18 {
7548 #[doc = "HuffBase RAM"]
7549 #[inline(always)]
7550 pub const fn huff_base_ram_0(&self) -> u16 {
7551 let val = (self.0 >> 0usize) & 0x01ff;
7552 val as u16
7553 }
7554 #[doc = "HuffBase RAM"]
7555 #[inline(always)]
7556 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7557 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7558 }
7559 #[doc = "HuffBase RAM"]
7560 #[inline(always)]
7561 pub const fn huff_base_ram_1(&self) -> u16 {
7562 let val = (self.0 >> 16usize) & 0x01ff;
7563 val as u16
7564 }
7565 #[doc = "HuffBase RAM"]
7566 #[inline(always)]
7567 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7568 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7569 }
7570 }
7571 impl Default for Huffbase18 {
7572 #[inline(always)]
7573 fn default() -> Huffbase18 {
7574 Huffbase18(0)
7575 }
7576 }
7577 impl core::fmt::Debug for Huffbase18 {
7578 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7579 f.debug_struct("Huffbase18")
7580 .field("huff_base_ram_0", &self.huff_base_ram_0())
7581 .field("huff_base_ram_1", &self.huff_base_ram_1())
7582 .finish()
7583 }
7584 }
7585 #[cfg(feature = "defmt")]
7586 impl defmt::Format for Huffbase18 {
7587 fn format(&self, f: defmt::Formatter) {
7588 #[derive(defmt :: Format)]
7589 struct Huffbase18 {
7590 huff_base_ram_0: u16,
7591 huff_base_ram_1: u16,
7592 }
7593 let proxy = Huffbase18 {
7594 huff_base_ram_0: self.huff_base_ram_0(),
7595 huff_base_ram_1: self.huff_base_ram_1(),
7596 };
7597 defmt::write!(f, "{}", proxy)
7598 }
7599 }
7600 #[doc = "JPEG HuffSymb tables"]
7601 #[repr(transparent)]
7602 #[derive(Copy, Clone, Eq, PartialEq)]
7603 pub struct Huffbase19(pub u32);
7604 impl Huffbase19 {
7605 #[doc = "HuffBase RAM"]
7606 #[inline(always)]
7607 pub const fn huff_base_ram_0(&self) -> u16 {
7608 let val = (self.0 >> 0usize) & 0x01ff;
7609 val as u16
7610 }
7611 #[doc = "HuffBase RAM"]
7612 #[inline(always)]
7613 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7614 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7615 }
7616 #[doc = "HuffBase RAM"]
7617 #[inline(always)]
7618 pub const fn huff_base_ram_1(&self) -> u16 {
7619 let val = (self.0 >> 16usize) & 0x01ff;
7620 val as u16
7621 }
7622 #[doc = "HuffBase RAM"]
7623 #[inline(always)]
7624 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7625 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7626 }
7627 }
7628 impl Default for Huffbase19 {
7629 #[inline(always)]
7630 fn default() -> Huffbase19 {
7631 Huffbase19(0)
7632 }
7633 }
7634 impl core::fmt::Debug for Huffbase19 {
7635 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7636 f.debug_struct("Huffbase19")
7637 .field("huff_base_ram_0", &self.huff_base_ram_0())
7638 .field("huff_base_ram_1", &self.huff_base_ram_1())
7639 .finish()
7640 }
7641 }
7642 #[cfg(feature = "defmt")]
7643 impl defmt::Format for Huffbase19 {
7644 fn format(&self, f: defmt::Formatter) {
7645 #[derive(defmt :: Format)]
7646 struct Huffbase19 {
7647 huff_base_ram_0: u16,
7648 huff_base_ram_1: u16,
7649 }
7650 let proxy = Huffbase19 {
7651 huff_base_ram_0: self.huff_base_ram_0(),
7652 huff_base_ram_1: self.huff_base_ram_1(),
7653 };
7654 defmt::write!(f, "{}", proxy)
7655 }
7656 }
7657 #[doc = "JPEG HuffSymb tables"]
7658 #[repr(transparent)]
7659 #[derive(Copy, Clone, Eq, PartialEq)]
7660 pub struct Huffbase2(pub u32);
7661 impl Huffbase2 {
7662 #[doc = "HuffBase RAM"]
7663 #[inline(always)]
7664 pub const fn huff_base_ram_0(&self) -> u16 {
7665 let val = (self.0 >> 0usize) & 0x01ff;
7666 val as u16
7667 }
7668 #[doc = "HuffBase RAM"]
7669 #[inline(always)]
7670 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7671 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7672 }
7673 #[doc = "HuffBase RAM"]
7674 #[inline(always)]
7675 pub const fn huff_base_ram_1(&self) -> u16 {
7676 let val = (self.0 >> 16usize) & 0x01ff;
7677 val as u16
7678 }
7679 #[doc = "HuffBase RAM"]
7680 #[inline(always)]
7681 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7682 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7683 }
7684 }
7685 impl Default for Huffbase2 {
7686 #[inline(always)]
7687 fn default() -> Huffbase2 {
7688 Huffbase2(0)
7689 }
7690 }
7691 impl core::fmt::Debug for Huffbase2 {
7692 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7693 f.debug_struct("Huffbase2")
7694 .field("huff_base_ram_0", &self.huff_base_ram_0())
7695 .field("huff_base_ram_1", &self.huff_base_ram_1())
7696 .finish()
7697 }
7698 }
7699 #[cfg(feature = "defmt")]
7700 impl defmt::Format for Huffbase2 {
7701 fn format(&self, f: defmt::Formatter) {
7702 #[derive(defmt :: Format)]
7703 struct Huffbase2 {
7704 huff_base_ram_0: u16,
7705 huff_base_ram_1: u16,
7706 }
7707 let proxy = Huffbase2 {
7708 huff_base_ram_0: self.huff_base_ram_0(),
7709 huff_base_ram_1: self.huff_base_ram_1(),
7710 };
7711 defmt::write!(f, "{}", proxy)
7712 }
7713 }
7714 #[doc = "JPEG HuffSymb tables"]
7715 #[repr(transparent)]
7716 #[derive(Copy, Clone, Eq, PartialEq)]
7717 pub struct Huffbase20(pub u32);
7718 impl Huffbase20 {
7719 #[doc = "HuffBase RAM"]
7720 #[inline(always)]
7721 pub const fn huff_base_ram_0(&self) -> u16 {
7722 let val = (self.0 >> 0usize) & 0x01ff;
7723 val as u16
7724 }
7725 #[doc = "HuffBase RAM"]
7726 #[inline(always)]
7727 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7728 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7729 }
7730 #[doc = "HuffBase RAM"]
7731 #[inline(always)]
7732 pub const fn huff_base_ram_1(&self) -> u16 {
7733 let val = (self.0 >> 16usize) & 0x01ff;
7734 val as u16
7735 }
7736 #[doc = "HuffBase RAM"]
7737 #[inline(always)]
7738 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7739 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7740 }
7741 }
7742 impl Default for Huffbase20 {
7743 #[inline(always)]
7744 fn default() -> Huffbase20 {
7745 Huffbase20(0)
7746 }
7747 }
7748 impl core::fmt::Debug for Huffbase20 {
7749 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7750 f.debug_struct("Huffbase20")
7751 .field("huff_base_ram_0", &self.huff_base_ram_0())
7752 .field("huff_base_ram_1", &self.huff_base_ram_1())
7753 .finish()
7754 }
7755 }
7756 #[cfg(feature = "defmt")]
7757 impl defmt::Format for Huffbase20 {
7758 fn format(&self, f: defmt::Formatter) {
7759 #[derive(defmt :: Format)]
7760 struct Huffbase20 {
7761 huff_base_ram_0: u16,
7762 huff_base_ram_1: u16,
7763 }
7764 let proxy = Huffbase20 {
7765 huff_base_ram_0: self.huff_base_ram_0(),
7766 huff_base_ram_1: self.huff_base_ram_1(),
7767 };
7768 defmt::write!(f, "{}", proxy)
7769 }
7770 }
7771 #[doc = "JPEG HuffSymb tables"]
7772 #[repr(transparent)]
7773 #[derive(Copy, Clone, Eq, PartialEq)]
7774 pub struct Huffbase21(pub u32);
7775 impl Huffbase21 {
7776 #[doc = "HuffBase RAM"]
7777 #[inline(always)]
7778 pub const fn huff_base_ram_0(&self) -> u16 {
7779 let val = (self.0 >> 0usize) & 0x01ff;
7780 val as u16
7781 }
7782 #[doc = "HuffBase RAM"]
7783 #[inline(always)]
7784 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7785 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7786 }
7787 #[doc = "HuffBase RAM"]
7788 #[inline(always)]
7789 pub const fn huff_base_ram_1(&self) -> u16 {
7790 let val = (self.0 >> 16usize) & 0x01ff;
7791 val as u16
7792 }
7793 #[doc = "HuffBase RAM"]
7794 #[inline(always)]
7795 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7796 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7797 }
7798 }
7799 impl Default for Huffbase21 {
7800 #[inline(always)]
7801 fn default() -> Huffbase21 {
7802 Huffbase21(0)
7803 }
7804 }
7805 impl core::fmt::Debug for Huffbase21 {
7806 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7807 f.debug_struct("Huffbase21")
7808 .field("huff_base_ram_0", &self.huff_base_ram_0())
7809 .field("huff_base_ram_1", &self.huff_base_ram_1())
7810 .finish()
7811 }
7812 }
7813 #[cfg(feature = "defmt")]
7814 impl defmt::Format for Huffbase21 {
7815 fn format(&self, f: defmt::Formatter) {
7816 #[derive(defmt :: Format)]
7817 struct Huffbase21 {
7818 huff_base_ram_0: u16,
7819 huff_base_ram_1: u16,
7820 }
7821 let proxy = Huffbase21 {
7822 huff_base_ram_0: self.huff_base_ram_0(),
7823 huff_base_ram_1: self.huff_base_ram_1(),
7824 };
7825 defmt::write!(f, "{}", proxy)
7826 }
7827 }
7828 #[doc = "JPEG HuffSymb tables"]
7829 #[repr(transparent)]
7830 #[derive(Copy, Clone, Eq, PartialEq)]
7831 pub struct Huffbase22(pub u32);
7832 impl Huffbase22 {
7833 #[doc = "HuffBase RAM"]
7834 #[inline(always)]
7835 pub const fn huff_base_ram_0(&self) -> u16 {
7836 let val = (self.0 >> 0usize) & 0x01ff;
7837 val as u16
7838 }
7839 #[doc = "HuffBase RAM"]
7840 #[inline(always)]
7841 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7842 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7843 }
7844 #[doc = "HuffBase RAM"]
7845 #[inline(always)]
7846 pub const fn huff_base_ram_1(&self) -> u16 {
7847 let val = (self.0 >> 16usize) & 0x01ff;
7848 val as u16
7849 }
7850 #[doc = "HuffBase RAM"]
7851 #[inline(always)]
7852 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7853 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7854 }
7855 }
7856 impl Default for Huffbase22 {
7857 #[inline(always)]
7858 fn default() -> Huffbase22 {
7859 Huffbase22(0)
7860 }
7861 }
7862 impl core::fmt::Debug for Huffbase22 {
7863 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7864 f.debug_struct("Huffbase22")
7865 .field("huff_base_ram_0", &self.huff_base_ram_0())
7866 .field("huff_base_ram_1", &self.huff_base_ram_1())
7867 .finish()
7868 }
7869 }
7870 #[cfg(feature = "defmt")]
7871 impl defmt::Format for Huffbase22 {
7872 fn format(&self, f: defmt::Formatter) {
7873 #[derive(defmt :: Format)]
7874 struct Huffbase22 {
7875 huff_base_ram_0: u16,
7876 huff_base_ram_1: u16,
7877 }
7878 let proxy = Huffbase22 {
7879 huff_base_ram_0: self.huff_base_ram_0(),
7880 huff_base_ram_1: self.huff_base_ram_1(),
7881 };
7882 defmt::write!(f, "{}", proxy)
7883 }
7884 }
7885 #[doc = "JPEG HuffSymb tables"]
7886 #[repr(transparent)]
7887 #[derive(Copy, Clone, Eq, PartialEq)]
7888 pub struct Huffbase23(pub u32);
7889 impl Huffbase23 {
7890 #[doc = "HuffBase RAM"]
7891 #[inline(always)]
7892 pub const fn huff_base_ram_0(&self) -> u16 {
7893 let val = (self.0 >> 0usize) & 0x01ff;
7894 val as u16
7895 }
7896 #[doc = "HuffBase RAM"]
7897 #[inline(always)]
7898 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7899 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7900 }
7901 #[doc = "HuffBase RAM"]
7902 #[inline(always)]
7903 pub const fn huff_base_ram_1(&self) -> u16 {
7904 let val = (self.0 >> 16usize) & 0x01ff;
7905 val as u16
7906 }
7907 #[doc = "HuffBase RAM"]
7908 #[inline(always)]
7909 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7910 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7911 }
7912 }
7913 impl Default for Huffbase23 {
7914 #[inline(always)]
7915 fn default() -> Huffbase23 {
7916 Huffbase23(0)
7917 }
7918 }
7919 impl core::fmt::Debug for Huffbase23 {
7920 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7921 f.debug_struct("Huffbase23")
7922 .field("huff_base_ram_0", &self.huff_base_ram_0())
7923 .field("huff_base_ram_1", &self.huff_base_ram_1())
7924 .finish()
7925 }
7926 }
7927 #[cfg(feature = "defmt")]
7928 impl defmt::Format for Huffbase23 {
7929 fn format(&self, f: defmt::Formatter) {
7930 #[derive(defmt :: Format)]
7931 struct Huffbase23 {
7932 huff_base_ram_0: u16,
7933 huff_base_ram_1: u16,
7934 }
7935 let proxy = Huffbase23 {
7936 huff_base_ram_0: self.huff_base_ram_0(),
7937 huff_base_ram_1: self.huff_base_ram_1(),
7938 };
7939 defmt::write!(f, "{}", proxy)
7940 }
7941 }
7942 #[doc = "JPEG HuffSymb tables"]
7943 #[repr(transparent)]
7944 #[derive(Copy, Clone, Eq, PartialEq)]
7945 pub struct Huffbase24(pub u32);
7946 impl Huffbase24 {
7947 #[doc = "HuffBase RAM"]
7948 #[inline(always)]
7949 pub const fn huff_base_ram_0(&self) -> u16 {
7950 let val = (self.0 >> 0usize) & 0x01ff;
7951 val as u16
7952 }
7953 #[doc = "HuffBase RAM"]
7954 #[inline(always)]
7955 pub fn set_huff_base_ram_0(&mut self, val: u16) {
7956 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
7957 }
7958 #[doc = "HuffBase RAM"]
7959 #[inline(always)]
7960 pub const fn huff_base_ram_1(&self) -> u16 {
7961 let val = (self.0 >> 16usize) & 0x01ff;
7962 val as u16
7963 }
7964 #[doc = "HuffBase RAM"]
7965 #[inline(always)]
7966 pub fn set_huff_base_ram_1(&mut self, val: u16) {
7967 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
7968 }
7969 }
7970 impl Default for Huffbase24 {
7971 #[inline(always)]
7972 fn default() -> Huffbase24 {
7973 Huffbase24(0)
7974 }
7975 }
7976 impl core::fmt::Debug for Huffbase24 {
7977 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
7978 f.debug_struct("Huffbase24")
7979 .field("huff_base_ram_0", &self.huff_base_ram_0())
7980 .field("huff_base_ram_1", &self.huff_base_ram_1())
7981 .finish()
7982 }
7983 }
7984 #[cfg(feature = "defmt")]
7985 impl defmt::Format for Huffbase24 {
7986 fn format(&self, f: defmt::Formatter) {
7987 #[derive(defmt :: Format)]
7988 struct Huffbase24 {
7989 huff_base_ram_0: u16,
7990 huff_base_ram_1: u16,
7991 }
7992 let proxy = Huffbase24 {
7993 huff_base_ram_0: self.huff_base_ram_0(),
7994 huff_base_ram_1: self.huff_base_ram_1(),
7995 };
7996 defmt::write!(f, "{}", proxy)
7997 }
7998 }
7999 #[doc = "JPEG HuffSymb tables"]
8000 #[repr(transparent)]
8001 #[derive(Copy, Clone, Eq, PartialEq)]
8002 pub struct Huffbase25(pub u32);
8003 impl Huffbase25 {
8004 #[doc = "HuffBase RAM"]
8005 #[inline(always)]
8006 pub const fn huff_base_ram_0(&self) -> u16 {
8007 let val = (self.0 >> 0usize) & 0x01ff;
8008 val as u16
8009 }
8010 #[doc = "HuffBase RAM"]
8011 #[inline(always)]
8012 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8013 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8014 }
8015 #[doc = "HuffBase RAM"]
8016 #[inline(always)]
8017 pub const fn huff_base_ram_1(&self) -> u16 {
8018 let val = (self.0 >> 16usize) & 0x01ff;
8019 val as u16
8020 }
8021 #[doc = "HuffBase RAM"]
8022 #[inline(always)]
8023 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8024 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8025 }
8026 }
8027 impl Default for Huffbase25 {
8028 #[inline(always)]
8029 fn default() -> Huffbase25 {
8030 Huffbase25(0)
8031 }
8032 }
8033 impl core::fmt::Debug for Huffbase25 {
8034 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8035 f.debug_struct("Huffbase25")
8036 .field("huff_base_ram_0", &self.huff_base_ram_0())
8037 .field("huff_base_ram_1", &self.huff_base_ram_1())
8038 .finish()
8039 }
8040 }
8041 #[cfg(feature = "defmt")]
8042 impl defmt::Format for Huffbase25 {
8043 fn format(&self, f: defmt::Formatter) {
8044 #[derive(defmt :: Format)]
8045 struct Huffbase25 {
8046 huff_base_ram_0: u16,
8047 huff_base_ram_1: u16,
8048 }
8049 let proxy = Huffbase25 {
8050 huff_base_ram_0: self.huff_base_ram_0(),
8051 huff_base_ram_1: self.huff_base_ram_1(),
8052 };
8053 defmt::write!(f, "{}", proxy)
8054 }
8055 }
8056 #[doc = "JPEG HuffSymb tables"]
8057 #[repr(transparent)]
8058 #[derive(Copy, Clone, Eq, PartialEq)]
8059 pub struct Huffbase26(pub u32);
8060 impl Huffbase26 {
8061 #[doc = "HuffBase RAM"]
8062 #[inline(always)]
8063 pub const fn huff_base_ram_0(&self) -> u16 {
8064 let val = (self.0 >> 0usize) & 0x01ff;
8065 val as u16
8066 }
8067 #[doc = "HuffBase RAM"]
8068 #[inline(always)]
8069 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8070 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8071 }
8072 #[doc = "HuffBase RAM"]
8073 #[inline(always)]
8074 pub const fn huff_base_ram_1(&self) -> u16 {
8075 let val = (self.0 >> 16usize) & 0x01ff;
8076 val as u16
8077 }
8078 #[doc = "HuffBase RAM"]
8079 #[inline(always)]
8080 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8081 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8082 }
8083 }
8084 impl Default for Huffbase26 {
8085 #[inline(always)]
8086 fn default() -> Huffbase26 {
8087 Huffbase26(0)
8088 }
8089 }
8090 impl core::fmt::Debug for Huffbase26 {
8091 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8092 f.debug_struct("Huffbase26")
8093 .field("huff_base_ram_0", &self.huff_base_ram_0())
8094 .field("huff_base_ram_1", &self.huff_base_ram_1())
8095 .finish()
8096 }
8097 }
8098 #[cfg(feature = "defmt")]
8099 impl defmt::Format for Huffbase26 {
8100 fn format(&self, f: defmt::Formatter) {
8101 #[derive(defmt :: Format)]
8102 struct Huffbase26 {
8103 huff_base_ram_0: u16,
8104 huff_base_ram_1: u16,
8105 }
8106 let proxy = Huffbase26 {
8107 huff_base_ram_0: self.huff_base_ram_0(),
8108 huff_base_ram_1: self.huff_base_ram_1(),
8109 };
8110 defmt::write!(f, "{}", proxy)
8111 }
8112 }
8113 #[doc = "JPEG HuffSymb tables"]
8114 #[repr(transparent)]
8115 #[derive(Copy, Clone, Eq, PartialEq)]
8116 pub struct Huffbase27(pub u32);
8117 impl Huffbase27 {
8118 #[doc = "HuffBase RAM"]
8119 #[inline(always)]
8120 pub const fn huff_base_ram_0(&self) -> u16 {
8121 let val = (self.0 >> 0usize) & 0x01ff;
8122 val as u16
8123 }
8124 #[doc = "HuffBase RAM"]
8125 #[inline(always)]
8126 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8127 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8128 }
8129 #[doc = "HuffBase RAM"]
8130 #[inline(always)]
8131 pub const fn huff_base_ram_1(&self) -> u16 {
8132 let val = (self.0 >> 16usize) & 0x01ff;
8133 val as u16
8134 }
8135 #[doc = "HuffBase RAM"]
8136 #[inline(always)]
8137 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8138 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8139 }
8140 }
8141 impl Default for Huffbase27 {
8142 #[inline(always)]
8143 fn default() -> Huffbase27 {
8144 Huffbase27(0)
8145 }
8146 }
8147 impl core::fmt::Debug for Huffbase27 {
8148 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8149 f.debug_struct("Huffbase27")
8150 .field("huff_base_ram_0", &self.huff_base_ram_0())
8151 .field("huff_base_ram_1", &self.huff_base_ram_1())
8152 .finish()
8153 }
8154 }
8155 #[cfg(feature = "defmt")]
8156 impl defmt::Format for Huffbase27 {
8157 fn format(&self, f: defmt::Formatter) {
8158 #[derive(defmt :: Format)]
8159 struct Huffbase27 {
8160 huff_base_ram_0: u16,
8161 huff_base_ram_1: u16,
8162 }
8163 let proxy = Huffbase27 {
8164 huff_base_ram_0: self.huff_base_ram_0(),
8165 huff_base_ram_1: self.huff_base_ram_1(),
8166 };
8167 defmt::write!(f, "{}", proxy)
8168 }
8169 }
8170 #[doc = "JPEG HuffSymb tables"]
8171 #[repr(transparent)]
8172 #[derive(Copy, Clone, Eq, PartialEq)]
8173 pub struct Huffbase28(pub u32);
8174 impl Huffbase28 {
8175 #[doc = "HuffBase RAM"]
8176 #[inline(always)]
8177 pub const fn huff_base_ram_0(&self) -> u16 {
8178 let val = (self.0 >> 0usize) & 0x01ff;
8179 val as u16
8180 }
8181 #[doc = "HuffBase RAM"]
8182 #[inline(always)]
8183 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8184 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8185 }
8186 #[doc = "HuffBase RAM"]
8187 #[inline(always)]
8188 pub const fn huff_base_ram_1(&self) -> u16 {
8189 let val = (self.0 >> 16usize) & 0x01ff;
8190 val as u16
8191 }
8192 #[doc = "HuffBase RAM"]
8193 #[inline(always)]
8194 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8195 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8196 }
8197 }
8198 impl Default for Huffbase28 {
8199 #[inline(always)]
8200 fn default() -> Huffbase28 {
8201 Huffbase28(0)
8202 }
8203 }
8204 impl core::fmt::Debug for Huffbase28 {
8205 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8206 f.debug_struct("Huffbase28")
8207 .field("huff_base_ram_0", &self.huff_base_ram_0())
8208 .field("huff_base_ram_1", &self.huff_base_ram_1())
8209 .finish()
8210 }
8211 }
8212 #[cfg(feature = "defmt")]
8213 impl defmt::Format for Huffbase28 {
8214 fn format(&self, f: defmt::Formatter) {
8215 #[derive(defmt :: Format)]
8216 struct Huffbase28 {
8217 huff_base_ram_0: u16,
8218 huff_base_ram_1: u16,
8219 }
8220 let proxy = Huffbase28 {
8221 huff_base_ram_0: self.huff_base_ram_0(),
8222 huff_base_ram_1: self.huff_base_ram_1(),
8223 };
8224 defmt::write!(f, "{}", proxy)
8225 }
8226 }
8227 #[doc = "JPEG HuffSymb tables"]
8228 #[repr(transparent)]
8229 #[derive(Copy, Clone, Eq, PartialEq)]
8230 pub struct Huffbase29(pub u32);
8231 impl Huffbase29 {
8232 #[doc = "HuffBase RAM"]
8233 #[inline(always)]
8234 pub const fn huff_base_ram_0(&self) -> u16 {
8235 let val = (self.0 >> 0usize) & 0x01ff;
8236 val as u16
8237 }
8238 #[doc = "HuffBase RAM"]
8239 #[inline(always)]
8240 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8241 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8242 }
8243 #[doc = "HuffBase RAM"]
8244 #[inline(always)]
8245 pub const fn huff_base_ram_1(&self) -> u16 {
8246 let val = (self.0 >> 16usize) & 0x01ff;
8247 val as u16
8248 }
8249 #[doc = "HuffBase RAM"]
8250 #[inline(always)]
8251 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8252 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8253 }
8254 }
8255 impl Default for Huffbase29 {
8256 #[inline(always)]
8257 fn default() -> Huffbase29 {
8258 Huffbase29(0)
8259 }
8260 }
8261 impl core::fmt::Debug for Huffbase29 {
8262 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8263 f.debug_struct("Huffbase29")
8264 .field("huff_base_ram_0", &self.huff_base_ram_0())
8265 .field("huff_base_ram_1", &self.huff_base_ram_1())
8266 .finish()
8267 }
8268 }
8269 #[cfg(feature = "defmt")]
8270 impl defmt::Format for Huffbase29 {
8271 fn format(&self, f: defmt::Formatter) {
8272 #[derive(defmt :: Format)]
8273 struct Huffbase29 {
8274 huff_base_ram_0: u16,
8275 huff_base_ram_1: u16,
8276 }
8277 let proxy = Huffbase29 {
8278 huff_base_ram_0: self.huff_base_ram_0(),
8279 huff_base_ram_1: self.huff_base_ram_1(),
8280 };
8281 defmt::write!(f, "{}", proxy)
8282 }
8283 }
8284 #[doc = "JPEG HuffSymb tables"]
8285 #[repr(transparent)]
8286 #[derive(Copy, Clone, Eq, PartialEq)]
8287 pub struct Huffbase3(pub u32);
8288 impl Huffbase3 {
8289 #[doc = "HuffBase RAM"]
8290 #[inline(always)]
8291 pub const fn huff_base_ram_0(&self) -> u16 {
8292 let val = (self.0 >> 0usize) & 0x01ff;
8293 val as u16
8294 }
8295 #[doc = "HuffBase RAM"]
8296 #[inline(always)]
8297 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8298 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8299 }
8300 #[doc = "HuffBase RAM"]
8301 #[inline(always)]
8302 pub const fn huff_base_ram_1(&self) -> u16 {
8303 let val = (self.0 >> 16usize) & 0x01ff;
8304 val as u16
8305 }
8306 #[doc = "HuffBase RAM"]
8307 #[inline(always)]
8308 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8309 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8310 }
8311 }
8312 impl Default for Huffbase3 {
8313 #[inline(always)]
8314 fn default() -> Huffbase3 {
8315 Huffbase3(0)
8316 }
8317 }
8318 impl core::fmt::Debug for Huffbase3 {
8319 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8320 f.debug_struct("Huffbase3")
8321 .field("huff_base_ram_0", &self.huff_base_ram_0())
8322 .field("huff_base_ram_1", &self.huff_base_ram_1())
8323 .finish()
8324 }
8325 }
8326 #[cfg(feature = "defmt")]
8327 impl defmt::Format for Huffbase3 {
8328 fn format(&self, f: defmt::Formatter) {
8329 #[derive(defmt :: Format)]
8330 struct Huffbase3 {
8331 huff_base_ram_0: u16,
8332 huff_base_ram_1: u16,
8333 }
8334 let proxy = Huffbase3 {
8335 huff_base_ram_0: self.huff_base_ram_0(),
8336 huff_base_ram_1: self.huff_base_ram_1(),
8337 };
8338 defmt::write!(f, "{}", proxy)
8339 }
8340 }
8341 #[doc = "JPEG HuffSymb tables"]
8342 #[repr(transparent)]
8343 #[derive(Copy, Clone, Eq, PartialEq)]
8344 pub struct Huffbase30(pub u32);
8345 impl Huffbase30 {
8346 #[doc = "HuffBase RAM"]
8347 #[inline(always)]
8348 pub const fn huff_base_ram_0(&self) -> u16 {
8349 let val = (self.0 >> 0usize) & 0x01ff;
8350 val as u16
8351 }
8352 #[doc = "HuffBase RAM"]
8353 #[inline(always)]
8354 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8355 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8356 }
8357 #[doc = "HuffBase RAM"]
8358 #[inline(always)]
8359 pub const fn huff_base_ram_1(&self) -> u16 {
8360 let val = (self.0 >> 16usize) & 0x01ff;
8361 val as u16
8362 }
8363 #[doc = "HuffBase RAM"]
8364 #[inline(always)]
8365 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8366 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8367 }
8368 }
8369 impl Default for Huffbase30 {
8370 #[inline(always)]
8371 fn default() -> Huffbase30 {
8372 Huffbase30(0)
8373 }
8374 }
8375 impl core::fmt::Debug for Huffbase30 {
8376 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8377 f.debug_struct("Huffbase30")
8378 .field("huff_base_ram_0", &self.huff_base_ram_0())
8379 .field("huff_base_ram_1", &self.huff_base_ram_1())
8380 .finish()
8381 }
8382 }
8383 #[cfg(feature = "defmt")]
8384 impl defmt::Format for Huffbase30 {
8385 fn format(&self, f: defmt::Formatter) {
8386 #[derive(defmt :: Format)]
8387 struct Huffbase30 {
8388 huff_base_ram_0: u16,
8389 huff_base_ram_1: u16,
8390 }
8391 let proxy = Huffbase30 {
8392 huff_base_ram_0: self.huff_base_ram_0(),
8393 huff_base_ram_1: self.huff_base_ram_1(),
8394 };
8395 defmt::write!(f, "{}", proxy)
8396 }
8397 }
8398 #[doc = "JPEG HuffSymb tables"]
8399 #[repr(transparent)]
8400 #[derive(Copy, Clone, Eq, PartialEq)]
8401 pub struct Huffbase31(pub u32);
8402 impl Huffbase31 {
8403 #[doc = "HuffBase RAM"]
8404 #[inline(always)]
8405 pub const fn huff_base_ram_0(&self) -> u16 {
8406 let val = (self.0 >> 0usize) & 0x01ff;
8407 val as u16
8408 }
8409 #[doc = "HuffBase RAM"]
8410 #[inline(always)]
8411 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8412 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8413 }
8414 #[doc = "HuffBase RAM"]
8415 #[inline(always)]
8416 pub const fn huff_base_ram_1(&self) -> u16 {
8417 let val = (self.0 >> 16usize) & 0x01ff;
8418 val as u16
8419 }
8420 #[doc = "HuffBase RAM"]
8421 #[inline(always)]
8422 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8423 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8424 }
8425 }
8426 impl Default for Huffbase31 {
8427 #[inline(always)]
8428 fn default() -> Huffbase31 {
8429 Huffbase31(0)
8430 }
8431 }
8432 impl core::fmt::Debug for Huffbase31 {
8433 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8434 f.debug_struct("Huffbase31")
8435 .field("huff_base_ram_0", &self.huff_base_ram_0())
8436 .field("huff_base_ram_1", &self.huff_base_ram_1())
8437 .finish()
8438 }
8439 }
8440 #[cfg(feature = "defmt")]
8441 impl defmt::Format for Huffbase31 {
8442 fn format(&self, f: defmt::Formatter) {
8443 #[derive(defmt :: Format)]
8444 struct Huffbase31 {
8445 huff_base_ram_0: u16,
8446 huff_base_ram_1: u16,
8447 }
8448 let proxy = Huffbase31 {
8449 huff_base_ram_0: self.huff_base_ram_0(),
8450 huff_base_ram_1: self.huff_base_ram_1(),
8451 };
8452 defmt::write!(f, "{}", proxy)
8453 }
8454 }
8455 #[doc = "JPEG HuffSymb tables"]
8456 #[repr(transparent)]
8457 #[derive(Copy, Clone, Eq, PartialEq)]
8458 pub struct Huffbase4(pub u32);
8459 impl Huffbase4 {
8460 #[doc = "HuffBase RAM"]
8461 #[inline(always)]
8462 pub const fn huff_base_ram_0(&self) -> u16 {
8463 let val = (self.0 >> 0usize) & 0x01ff;
8464 val as u16
8465 }
8466 #[doc = "HuffBase RAM"]
8467 #[inline(always)]
8468 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8469 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8470 }
8471 #[doc = "HuffBase RAM"]
8472 #[inline(always)]
8473 pub const fn huff_base_ram_1(&self) -> u16 {
8474 let val = (self.0 >> 16usize) & 0x01ff;
8475 val as u16
8476 }
8477 #[doc = "HuffBase RAM"]
8478 #[inline(always)]
8479 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8480 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8481 }
8482 }
8483 impl Default for Huffbase4 {
8484 #[inline(always)]
8485 fn default() -> Huffbase4 {
8486 Huffbase4(0)
8487 }
8488 }
8489 impl core::fmt::Debug for Huffbase4 {
8490 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8491 f.debug_struct("Huffbase4")
8492 .field("huff_base_ram_0", &self.huff_base_ram_0())
8493 .field("huff_base_ram_1", &self.huff_base_ram_1())
8494 .finish()
8495 }
8496 }
8497 #[cfg(feature = "defmt")]
8498 impl defmt::Format for Huffbase4 {
8499 fn format(&self, f: defmt::Formatter) {
8500 #[derive(defmt :: Format)]
8501 struct Huffbase4 {
8502 huff_base_ram_0: u16,
8503 huff_base_ram_1: u16,
8504 }
8505 let proxy = Huffbase4 {
8506 huff_base_ram_0: self.huff_base_ram_0(),
8507 huff_base_ram_1: self.huff_base_ram_1(),
8508 };
8509 defmt::write!(f, "{}", proxy)
8510 }
8511 }
8512 #[doc = "JPEG HuffSymb tables"]
8513 #[repr(transparent)]
8514 #[derive(Copy, Clone, Eq, PartialEq)]
8515 pub struct Huffbase5(pub u32);
8516 impl Huffbase5 {
8517 #[doc = "HuffBase RAM"]
8518 #[inline(always)]
8519 pub const fn huff_base_ram_0(&self) -> u16 {
8520 let val = (self.0 >> 0usize) & 0x01ff;
8521 val as u16
8522 }
8523 #[doc = "HuffBase RAM"]
8524 #[inline(always)]
8525 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8526 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8527 }
8528 #[doc = "HuffBase RAM"]
8529 #[inline(always)]
8530 pub const fn huff_base_ram_1(&self) -> u16 {
8531 let val = (self.0 >> 16usize) & 0x01ff;
8532 val as u16
8533 }
8534 #[doc = "HuffBase RAM"]
8535 #[inline(always)]
8536 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8537 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8538 }
8539 }
8540 impl Default for Huffbase5 {
8541 #[inline(always)]
8542 fn default() -> Huffbase5 {
8543 Huffbase5(0)
8544 }
8545 }
8546 impl core::fmt::Debug for Huffbase5 {
8547 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8548 f.debug_struct("Huffbase5")
8549 .field("huff_base_ram_0", &self.huff_base_ram_0())
8550 .field("huff_base_ram_1", &self.huff_base_ram_1())
8551 .finish()
8552 }
8553 }
8554 #[cfg(feature = "defmt")]
8555 impl defmt::Format for Huffbase5 {
8556 fn format(&self, f: defmt::Formatter) {
8557 #[derive(defmt :: Format)]
8558 struct Huffbase5 {
8559 huff_base_ram_0: u16,
8560 huff_base_ram_1: u16,
8561 }
8562 let proxy = Huffbase5 {
8563 huff_base_ram_0: self.huff_base_ram_0(),
8564 huff_base_ram_1: self.huff_base_ram_1(),
8565 };
8566 defmt::write!(f, "{}", proxy)
8567 }
8568 }
8569 #[doc = "JPEG HuffSymb tables"]
8570 #[repr(transparent)]
8571 #[derive(Copy, Clone, Eq, PartialEq)]
8572 pub struct Huffbase6(pub u32);
8573 impl Huffbase6 {
8574 #[doc = "HuffBase RAM"]
8575 #[inline(always)]
8576 pub const fn huff_base_ram_0(&self) -> u16 {
8577 let val = (self.0 >> 0usize) & 0x01ff;
8578 val as u16
8579 }
8580 #[doc = "HuffBase RAM"]
8581 #[inline(always)]
8582 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8583 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8584 }
8585 #[doc = "HuffBase RAM"]
8586 #[inline(always)]
8587 pub const fn huff_base_ram_1(&self) -> u16 {
8588 let val = (self.0 >> 16usize) & 0x01ff;
8589 val as u16
8590 }
8591 #[doc = "HuffBase RAM"]
8592 #[inline(always)]
8593 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8594 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8595 }
8596 }
8597 impl Default for Huffbase6 {
8598 #[inline(always)]
8599 fn default() -> Huffbase6 {
8600 Huffbase6(0)
8601 }
8602 }
8603 impl core::fmt::Debug for Huffbase6 {
8604 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8605 f.debug_struct("Huffbase6")
8606 .field("huff_base_ram_0", &self.huff_base_ram_0())
8607 .field("huff_base_ram_1", &self.huff_base_ram_1())
8608 .finish()
8609 }
8610 }
8611 #[cfg(feature = "defmt")]
8612 impl defmt::Format for Huffbase6 {
8613 fn format(&self, f: defmt::Formatter) {
8614 #[derive(defmt :: Format)]
8615 struct Huffbase6 {
8616 huff_base_ram_0: u16,
8617 huff_base_ram_1: u16,
8618 }
8619 let proxy = Huffbase6 {
8620 huff_base_ram_0: self.huff_base_ram_0(),
8621 huff_base_ram_1: self.huff_base_ram_1(),
8622 };
8623 defmt::write!(f, "{}", proxy)
8624 }
8625 }
8626 #[doc = "JPEG HuffSymb tables"]
8627 #[repr(transparent)]
8628 #[derive(Copy, Clone, Eq, PartialEq)]
8629 pub struct Huffbase7(pub u32);
8630 impl Huffbase7 {
8631 #[doc = "HuffBase RAM"]
8632 #[inline(always)]
8633 pub const fn huff_base_ram_0(&self) -> u16 {
8634 let val = (self.0 >> 0usize) & 0x01ff;
8635 val as u16
8636 }
8637 #[doc = "HuffBase RAM"]
8638 #[inline(always)]
8639 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8640 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8641 }
8642 #[doc = "HuffBase RAM"]
8643 #[inline(always)]
8644 pub const fn huff_base_ram_1(&self) -> u16 {
8645 let val = (self.0 >> 16usize) & 0x01ff;
8646 val as u16
8647 }
8648 #[doc = "HuffBase RAM"]
8649 #[inline(always)]
8650 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8651 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8652 }
8653 }
8654 impl Default for Huffbase7 {
8655 #[inline(always)]
8656 fn default() -> Huffbase7 {
8657 Huffbase7(0)
8658 }
8659 }
8660 impl core::fmt::Debug for Huffbase7 {
8661 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8662 f.debug_struct("Huffbase7")
8663 .field("huff_base_ram_0", &self.huff_base_ram_0())
8664 .field("huff_base_ram_1", &self.huff_base_ram_1())
8665 .finish()
8666 }
8667 }
8668 #[cfg(feature = "defmt")]
8669 impl defmt::Format for Huffbase7 {
8670 fn format(&self, f: defmt::Formatter) {
8671 #[derive(defmt :: Format)]
8672 struct Huffbase7 {
8673 huff_base_ram_0: u16,
8674 huff_base_ram_1: u16,
8675 }
8676 let proxy = Huffbase7 {
8677 huff_base_ram_0: self.huff_base_ram_0(),
8678 huff_base_ram_1: self.huff_base_ram_1(),
8679 };
8680 defmt::write!(f, "{}", proxy)
8681 }
8682 }
8683 #[doc = "JPEG HuffSymb tables"]
8684 #[repr(transparent)]
8685 #[derive(Copy, Clone, Eq, PartialEq)]
8686 pub struct Huffbase8(pub u32);
8687 impl Huffbase8 {
8688 #[doc = "HuffBase RAM"]
8689 #[inline(always)]
8690 pub const fn huff_base_ram_0(&self) -> u16 {
8691 let val = (self.0 >> 0usize) & 0x01ff;
8692 val as u16
8693 }
8694 #[doc = "HuffBase RAM"]
8695 #[inline(always)]
8696 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8697 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8698 }
8699 #[doc = "HuffBase RAM"]
8700 #[inline(always)]
8701 pub const fn huff_base_ram_1(&self) -> u16 {
8702 let val = (self.0 >> 16usize) & 0x01ff;
8703 val as u16
8704 }
8705 #[doc = "HuffBase RAM"]
8706 #[inline(always)]
8707 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8708 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8709 }
8710 }
8711 impl Default for Huffbase8 {
8712 #[inline(always)]
8713 fn default() -> Huffbase8 {
8714 Huffbase8(0)
8715 }
8716 }
8717 impl core::fmt::Debug for Huffbase8 {
8718 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8719 f.debug_struct("Huffbase8")
8720 .field("huff_base_ram_0", &self.huff_base_ram_0())
8721 .field("huff_base_ram_1", &self.huff_base_ram_1())
8722 .finish()
8723 }
8724 }
8725 #[cfg(feature = "defmt")]
8726 impl defmt::Format for Huffbase8 {
8727 fn format(&self, f: defmt::Formatter) {
8728 #[derive(defmt :: Format)]
8729 struct Huffbase8 {
8730 huff_base_ram_0: u16,
8731 huff_base_ram_1: u16,
8732 }
8733 let proxy = Huffbase8 {
8734 huff_base_ram_0: self.huff_base_ram_0(),
8735 huff_base_ram_1: self.huff_base_ram_1(),
8736 };
8737 defmt::write!(f, "{}", proxy)
8738 }
8739 }
8740 #[doc = "JPEG HuffSymb tables"]
8741 #[repr(transparent)]
8742 #[derive(Copy, Clone, Eq, PartialEq)]
8743 pub struct Huffbase9(pub u32);
8744 impl Huffbase9 {
8745 #[doc = "HuffBase RAM"]
8746 #[inline(always)]
8747 pub const fn huff_base_ram_0(&self) -> u16 {
8748 let val = (self.0 >> 0usize) & 0x01ff;
8749 val as u16
8750 }
8751 #[doc = "HuffBase RAM"]
8752 #[inline(always)]
8753 pub fn set_huff_base_ram_0(&mut self, val: u16) {
8754 self.0 = (self.0 & !(0x01ff << 0usize)) | (((val as u32) & 0x01ff) << 0usize);
8755 }
8756 #[doc = "HuffBase RAM"]
8757 #[inline(always)]
8758 pub const fn huff_base_ram_1(&self) -> u16 {
8759 let val = (self.0 >> 16usize) & 0x01ff;
8760 val as u16
8761 }
8762 #[doc = "HuffBase RAM"]
8763 #[inline(always)]
8764 pub fn set_huff_base_ram_1(&mut self, val: u16) {
8765 self.0 = (self.0 & !(0x01ff << 16usize)) | (((val as u32) & 0x01ff) << 16usize);
8766 }
8767 }
8768 impl Default for Huffbase9 {
8769 #[inline(always)]
8770 fn default() -> Huffbase9 {
8771 Huffbase9(0)
8772 }
8773 }
8774 impl core::fmt::Debug for Huffbase9 {
8775 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8776 f.debug_struct("Huffbase9")
8777 .field("huff_base_ram_0", &self.huff_base_ram_0())
8778 .field("huff_base_ram_1", &self.huff_base_ram_1())
8779 .finish()
8780 }
8781 }
8782 #[cfg(feature = "defmt")]
8783 impl defmt::Format for Huffbase9 {
8784 fn format(&self, f: defmt::Formatter) {
8785 #[derive(defmt :: Format)]
8786 struct Huffbase9 {
8787 huff_base_ram_0: u16,
8788 huff_base_ram_1: u16,
8789 }
8790 let proxy = Huffbase9 {
8791 huff_base_ram_0: self.huff_base_ram_0(),
8792 huff_base_ram_1: self.huff_base_ram_1(),
8793 };
8794 defmt::write!(f, "{}", proxy)
8795 }
8796 }
8797 #[doc = "JPEG encoder, AC Huffman table 0"]
8798 #[repr(transparent)]
8799 #[derive(Copy, Clone, Eq, PartialEq)]
8800 pub struct HuffencAc00(pub u32);
8801 impl HuffencAc00 {
8802 #[doc = "DHTMem RAM"]
8803 #[inline(always)]
8804 pub const fn dhtmem_ram(&self) -> u32 {
8805 let val = (self.0 >> 0usize) & 0xffff_ffff;
8806 val as u32
8807 }
8808 #[doc = "DHTMem RAM"]
8809 #[inline(always)]
8810 pub fn set_dhtmem_ram(&mut self, val: u32) {
8811 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
8812 }
8813 }
8814 impl Default for HuffencAc00 {
8815 #[inline(always)]
8816 fn default() -> HuffencAc00 {
8817 HuffencAc00(0)
8818 }
8819 }
8820 impl core::fmt::Debug for HuffencAc00 {
8821 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8822 f.debug_struct("HuffencAc00")
8823 .field("dhtmem_ram", &self.dhtmem_ram())
8824 .finish()
8825 }
8826 }
8827 #[cfg(feature = "defmt")]
8828 impl defmt::Format for HuffencAc00 {
8829 fn format(&self, f: defmt::Formatter) {
8830 #[derive(defmt :: Format)]
8831 struct HuffencAc00 {
8832 dhtmem_ram: u32,
8833 }
8834 let proxy = HuffencAc00 {
8835 dhtmem_ram: self.dhtmem_ram(),
8836 };
8837 defmt::write!(f, "{}", proxy)
8838 }
8839 }
8840 #[doc = "JPEG encoder, AC Huffman table 0"]
8841 #[repr(transparent)]
8842 #[derive(Copy, Clone, Eq, PartialEq)]
8843 pub struct HuffencAc01(pub u32);
8844 impl HuffencAc01 {
8845 #[doc = "DHTMem RAM"]
8846 #[inline(always)]
8847 pub const fn dhtmem_ram(&self) -> u32 {
8848 let val = (self.0 >> 0usize) & 0xffff_ffff;
8849 val as u32
8850 }
8851 #[doc = "DHTMem RAM"]
8852 #[inline(always)]
8853 pub fn set_dhtmem_ram(&mut self, val: u32) {
8854 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
8855 }
8856 }
8857 impl Default for HuffencAc01 {
8858 #[inline(always)]
8859 fn default() -> HuffencAc01 {
8860 HuffencAc01(0)
8861 }
8862 }
8863 impl core::fmt::Debug for HuffencAc01 {
8864 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8865 f.debug_struct("HuffencAc01")
8866 .field("dhtmem_ram", &self.dhtmem_ram())
8867 .finish()
8868 }
8869 }
8870 #[cfg(feature = "defmt")]
8871 impl defmt::Format for HuffencAc01 {
8872 fn format(&self, f: defmt::Formatter) {
8873 #[derive(defmt :: Format)]
8874 struct HuffencAc01 {
8875 dhtmem_ram: u32,
8876 }
8877 let proxy = HuffencAc01 {
8878 dhtmem_ram: self.dhtmem_ram(),
8879 };
8880 defmt::write!(f, "{}", proxy)
8881 }
8882 }
8883 #[doc = "JPEG encoder, AC Huffman table 0"]
8884 #[repr(transparent)]
8885 #[derive(Copy, Clone, Eq, PartialEq)]
8886 pub struct HuffencAc010(pub u32);
8887 impl HuffencAc010 {
8888 #[doc = "DHTMem RAM"]
8889 #[inline(always)]
8890 pub const fn dhtmem_ram(&self) -> u32 {
8891 let val = (self.0 >> 0usize) & 0xffff_ffff;
8892 val as u32
8893 }
8894 #[doc = "DHTMem RAM"]
8895 #[inline(always)]
8896 pub fn set_dhtmem_ram(&mut self, val: u32) {
8897 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
8898 }
8899 }
8900 impl Default for HuffencAc010 {
8901 #[inline(always)]
8902 fn default() -> HuffencAc010 {
8903 HuffencAc010(0)
8904 }
8905 }
8906 impl core::fmt::Debug for HuffencAc010 {
8907 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8908 f.debug_struct("HuffencAc010")
8909 .field("dhtmem_ram", &self.dhtmem_ram())
8910 .finish()
8911 }
8912 }
8913 #[cfg(feature = "defmt")]
8914 impl defmt::Format for HuffencAc010 {
8915 fn format(&self, f: defmt::Formatter) {
8916 #[derive(defmt :: Format)]
8917 struct HuffencAc010 {
8918 dhtmem_ram: u32,
8919 }
8920 let proxy = HuffencAc010 {
8921 dhtmem_ram: self.dhtmem_ram(),
8922 };
8923 defmt::write!(f, "{}", proxy)
8924 }
8925 }
8926 #[doc = "JPEG encoder, AC Huffman table 0"]
8927 #[repr(transparent)]
8928 #[derive(Copy, Clone, Eq, PartialEq)]
8929 pub struct HuffencAc011(pub u32);
8930 impl HuffencAc011 {
8931 #[doc = "DHTMem RAM"]
8932 #[inline(always)]
8933 pub const fn dhtmem_ram(&self) -> u32 {
8934 let val = (self.0 >> 0usize) & 0xffff_ffff;
8935 val as u32
8936 }
8937 #[doc = "DHTMem RAM"]
8938 #[inline(always)]
8939 pub fn set_dhtmem_ram(&mut self, val: u32) {
8940 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
8941 }
8942 }
8943 impl Default for HuffencAc011 {
8944 #[inline(always)]
8945 fn default() -> HuffencAc011 {
8946 HuffencAc011(0)
8947 }
8948 }
8949 impl core::fmt::Debug for HuffencAc011 {
8950 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8951 f.debug_struct("HuffencAc011")
8952 .field("dhtmem_ram", &self.dhtmem_ram())
8953 .finish()
8954 }
8955 }
8956 #[cfg(feature = "defmt")]
8957 impl defmt::Format for HuffencAc011 {
8958 fn format(&self, f: defmt::Formatter) {
8959 #[derive(defmt :: Format)]
8960 struct HuffencAc011 {
8961 dhtmem_ram: u32,
8962 }
8963 let proxy = HuffencAc011 {
8964 dhtmem_ram: self.dhtmem_ram(),
8965 };
8966 defmt::write!(f, "{}", proxy)
8967 }
8968 }
8969 #[doc = "JPEG encoder, AC Huffman table 0"]
8970 #[repr(transparent)]
8971 #[derive(Copy, Clone, Eq, PartialEq)]
8972 pub struct HuffencAc012(pub u32);
8973 impl HuffencAc012 {
8974 #[doc = "DHTMem RAM"]
8975 #[inline(always)]
8976 pub const fn dhtmem_ram(&self) -> u32 {
8977 let val = (self.0 >> 0usize) & 0xffff_ffff;
8978 val as u32
8979 }
8980 #[doc = "DHTMem RAM"]
8981 #[inline(always)]
8982 pub fn set_dhtmem_ram(&mut self, val: u32) {
8983 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
8984 }
8985 }
8986 impl Default for HuffencAc012 {
8987 #[inline(always)]
8988 fn default() -> HuffencAc012 {
8989 HuffencAc012(0)
8990 }
8991 }
8992 impl core::fmt::Debug for HuffencAc012 {
8993 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
8994 f.debug_struct("HuffencAc012")
8995 .field("dhtmem_ram", &self.dhtmem_ram())
8996 .finish()
8997 }
8998 }
8999 #[cfg(feature = "defmt")]
9000 impl defmt::Format for HuffencAc012 {
9001 fn format(&self, f: defmt::Formatter) {
9002 #[derive(defmt :: Format)]
9003 struct HuffencAc012 {
9004 dhtmem_ram: u32,
9005 }
9006 let proxy = HuffencAc012 {
9007 dhtmem_ram: self.dhtmem_ram(),
9008 };
9009 defmt::write!(f, "{}", proxy)
9010 }
9011 }
9012 #[doc = "JPEG encoder, AC Huffman table 0"]
9013 #[repr(transparent)]
9014 #[derive(Copy, Clone, Eq, PartialEq)]
9015 pub struct HuffencAc013(pub u32);
9016 impl HuffencAc013 {
9017 #[doc = "DHTMem RAM"]
9018 #[inline(always)]
9019 pub const fn dhtmem_ram(&self) -> u32 {
9020 let val = (self.0 >> 0usize) & 0xffff_ffff;
9021 val as u32
9022 }
9023 #[doc = "DHTMem RAM"]
9024 #[inline(always)]
9025 pub fn set_dhtmem_ram(&mut self, val: u32) {
9026 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9027 }
9028 }
9029 impl Default for HuffencAc013 {
9030 #[inline(always)]
9031 fn default() -> HuffencAc013 {
9032 HuffencAc013(0)
9033 }
9034 }
9035 impl core::fmt::Debug for HuffencAc013 {
9036 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9037 f.debug_struct("HuffencAc013")
9038 .field("dhtmem_ram", &self.dhtmem_ram())
9039 .finish()
9040 }
9041 }
9042 #[cfg(feature = "defmt")]
9043 impl defmt::Format for HuffencAc013 {
9044 fn format(&self, f: defmt::Formatter) {
9045 #[derive(defmt :: Format)]
9046 struct HuffencAc013 {
9047 dhtmem_ram: u32,
9048 }
9049 let proxy = HuffencAc013 {
9050 dhtmem_ram: self.dhtmem_ram(),
9051 };
9052 defmt::write!(f, "{}", proxy)
9053 }
9054 }
9055 #[doc = "JPEG encoder, AC Huffman table 0"]
9056 #[repr(transparent)]
9057 #[derive(Copy, Clone, Eq, PartialEq)]
9058 pub struct HuffencAc014(pub u32);
9059 impl HuffencAc014 {
9060 #[doc = "DHTMem RAM"]
9061 #[inline(always)]
9062 pub const fn dhtmem_ram(&self) -> u32 {
9063 let val = (self.0 >> 0usize) & 0xffff_ffff;
9064 val as u32
9065 }
9066 #[doc = "DHTMem RAM"]
9067 #[inline(always)]
9068 pub fn set_dhtmem_ram(&mut self, val: u32) {
9069 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9070 }
9071 }
9072 impl Default for HuffencAc014 {
9073 #[inline(always)]
9074 fn default() -> HuffencAc014 {
9075 HuffencAc014(0)
9076 }
9077 }
9078 impl core::fmt::Debug for HuffencAc014 {
9079 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9080 f.debug_struct("HuffencAc014")
9081 .field("dhtmem_ram", &self.dhtmem_ram())
9082 .finish()
9083 }
9084 }
9085 #[cfg(feature = "defmt")]
9086 impl defmt::Format for HuffencAc014 {
9087 fn format(&self, f: defmt::Formatter) {
9088 #[derive(defmt :: Format)]
9089 struct HuffencAc014 {
9090 dhtmem_ram: u32,
9091 }
9092 let proxy = HuffencAc014 {
9093 dhtmem_ram: self.dhtmem_ram(),
9094 };
9095 defmt::write!(f, "{}", proxy)
9096 }
9097 }
9098 #[doc = "JPEG encoder, AC Huffman table 0"]
9099 #[repr(transparent)]
9100 #[derive(Copy, Clone, Eq, PartialEq)]
9101 pub struct HuffencAc015(pub u32);
9102 impl HuffencAc015 {
9103 #[doc = "DHTMem RAM"]
9104 #[inline(always)]
9105 pub const fn dhtmem_ram(&self) -> u32 {
9106 let val = (self.0 >> 0usize) & 0xffff_ffff;
9107 val as u32
9108 }
9109 #[doc = "DHTMem RAM"]
9110 #[inline(always)]
9111 pub fn set_dhtmem_ram(&mut self, val: u32) {
9112 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9113 }
9114 }
9115 impl Default for HuffencAc015 {
9116 #[inline(always)]
9117 fn default() -> HuffencAc015 {
9118 HuffencAc015(0)
9119 }
9120 }
9121 impl core::fmt::Debug for HuffencAc015 {
9122 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9123 f.debug_struct("HuffencAc015")
9124 .field("dhtmem_ram", &self.dhtmem_ram())
9125 .finish()
9126 }
9127 }
9128 #[cfg(feature = "defmt")]
9129 impl defmt::Format for HuffencAc015 {
9130 fn format(&self, f: defmt::Formatter) {
9131 #[derive(defmt :: Format)]
9132 struct HuffencAc015 {
9133 dhtmem_ram: u32,
9134 }
9135 let proxy = HuffencAc015 {
9136 dhtmem_ram: self.dhtmem_ram(),
9137 };
9138 defmt::write!(f, "{}", proxy)
9139 }
9140 }
9141 #[doc = "JPEG encoder, AC Huffman table 0"]
9142 #[repr(transparent)]
9143 #[derive(Copy, Clone, Eq, PartialEq)]
9144 pub struct HuffencAc016(pub u32);
9145 impl HuffencAc016 {
9146 #[doc = "DHTMem RAM"]
9147 #[inline(always)]
9148 pub const fn dhtmem_ram(&self) -> u32 {
9149 let val = (self.0 >> 0usize) & 0xffff_ffff;
9150 val as u32
9151 }
9152 #[doc = "DHTMem RAM"]
9153 #[inline(always)]
9154 pub fn set_dhtmem_ram(&mut self, val: u32) {
9155 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9156 }
9157 }
9158 impl Default for HuffencAc016 {
9159 #[inline(always)]
9160 fn default() -> HuffencAc016 {
9161 HuffencAc016(0)
9162 }
9163 }
9164 impl core::fmt::Debug for HuffencAc016 {
9165 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9166 f.debug_struct("HuffencAc016")
9167 .field("dhtmem_ram", &self.dhtmem_ram())
9168 .finish()
9169 }
9170 }
9171 #[cfg(feature = "defmt")]
9172 impl defmt::Format for HuffencAc016 {
9173 fn format(&self, f: defmt::Formatter) {
9174 #[derive(defmt :: Format)]
9175 struct HuffencAc016 {
9176 dhtmem_ram: u32,
9177 }
9178 let proxy = HuffencAc016 {
9179 dhtmem_ram: self.dhtmem_ram(),
9180 };
9181 defmt::write!(f, "{}", proxy)
9182 }
9183 }
9184 #[doc = "JPEG encoder, AC Huffman table 0"]
9185 #[repr(transparent)]
9186 #[derive(Copy, Clone, Eq, PartialEq)]
9187 pub struct HuffencAc017(pub u32);
9188 impl HuffencAc017 {
9189 #[doc = "DHTMem RAM"]
9190 #[inline(always)]
9191 pub const fn dhtmem_ram(&self) -> u32 {
9192 let val = (self.0 >> 0usize) & 0xffff_ffff;
9193 val as u32
9194 }
9195 #[doc = "DHTMem RAM"]
9196 #[inline(always)]
9197 pub fn set_dhtmem_ram(&mut self, val: u32) {
9198 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9199 }
9200 }
9201 impl Default for HuffencAc017 {
9202 #[inline(always)]
9203 fn default() -> HuffencAc017 {
9204 HuffencAc017(0)
9205 }
9206 }
9207 impl core::fmt::Debug for HuffencAc017 {
9208 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9209 f.debug_struct("HuffencAc017")
9210 .field("dhtmem_ram", &self.dhtmem_ram())
9211 .finish()
9212 }
9213 }
9214 #[cfg(feature = "defmt")]
9215 impl defmt::Format for HuffencAc017 {
9216 fn format(&self, f: defmt::Formatter) {
9217 #[derive(defmt :: Format)]
9218 struct HuffencAc017 {
9219 dhtmem_ram: u32,
9220 }
9221 let proxy = HuffencAc017 {
9222 dhtmem_ram: self.dhtmem_ram(),
9223 };
9224 defmt::write!(f, "{}", proxy)
9225 }
9226 }
9227 #[doc = "JPEG encoder, AC Huffman table 0"]
9228 #[repr(transparent)]
9229 #[derive(Copy, Clone, Eq, PartialEq)]
9230 pub struct HuffencAc018(pub u32);
9231 impl HuffencAc018 {
9232 #[doc = "DHTMem RAM"]
9233 #[inline(always)]
9234 pub const fn dhtmem_ram(&self) -> u32 {
9235 let val = (self.0 >> 0usize) & 0xffff_ffff;
9236 val as u32
9237 }
9238 #[doc = "DHTMem RAM"]
9239 #[inline(always)]
9240 pub fn set_dhtmem_ram(&mut self, val: u32) {
9241 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9242 }
9243 }
9244 impl Default for HuffencAc018 {
9245 #[inline(always)]
9246 fn default() -> HuffencAc018 {
9247 HuffencAc018(0)
9248 }
9249 }
9250 impl core::fmt::Debug for HuffencAc018 {
9251 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9252 f.debug_struct("HuffencAc018")
9253 .field("dhtmem_ram", &self.dhtmem_ram())
9254 .finish()
9255 }
9256 }
9257 #[cfg(feature = "defmt")]
9258 impl defmt::Format for HuffencAc018 {
9259 fn format(&self, f: defmt::Formatter) {
9260 #[derive(defmt :: Format)]
9261 struct HuffencAc018 {
9262 dhtmem_ram: u32,
9263 }
9264 let proxy = HuffencAc018 {
9265 dhtmem_ram: self.dhtmem_ram(),
9266 };
9267 defmt::write!(f, "{}", proxy)
9268 }
9269 }
9270 #[doc = "JPEG encoder, AC Huffman table 0"]
9271 #[repr(transparent)]
9272 #[derive(Copy, Clone, Eq, PartialEq)]
9273 pub struct HuffencAc019(pub u32);
9274 impl HuffencAc019 {
9275 #[doc = "DHTMem RAM"]
9276 #[inline(always)]
9277 pub const fn dhtmem_ram(&self) -> u32 {
9278 let val = (self.0 >> 0usize) & 0xffff_ffff;
9279 val as u32
9280 }
9281 #[doc = "DHTMem RAM"]
9282 #[inline(always)]
9283 pub fn set_dhtmem_ram(&mut self, val: u32) {
9284 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9285 }
9286 }
9287 impl Default for HuffencAc019 {
9288 #[inline(always)]
9289 fn default() -> HuffencAc019 {
9290 HuffencAc019(0)
9291 }
9292 }
9293 impl core::fmt::Debug for HuffencAc019 {
9294 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9295 f.debug_struct("HuffencAc019")
9296 .field("dhtmem_ram", &self.dhtmem_ram())
9297 .finish()
9298 }
9299 }
9300 #[cfg(feature = "defmt")]
9301 impl defmt::Format for HuffencAc019 {
9302 fn format(&self, f: defmt::Formatter) {
9303 #[derive(defmt :: Format)]
9304 struct HuffencAc019 {
9305 dhtmem_ram: u32,
9306 }
9307 let proxy = HuffencAc019 {
9308 dhtmem_ram: self.dhtmem_ram(),
9309 };
9310 defmt::write!(f, "{}", proxy)
9311 }
9312 }
9313 #[doc = "JPEG encoder, AC Huffman table 0"]
9314 #[repr(transparent)]
9315 #[derive(Copy, Clone, Eq, PartialEq)]
9316 pub struct HuffencAc02(pub u32);
9317 impl HuffencAc02 {
9318 #[doc = "DHTMem RAM"]
9319 #[inline(always)]
9320 pub const fn dhtmem_ram(&self) -> u32 {
9321 let val = (self.0 >> 0usize) & 0xffff_ffff;
9322 val as u32
9323 }
9324 #[doc = "DHTMem RAM"]
9325 #[inline(always)]
9326 pub fn set_dhtmem_ram(&mut self, val: u32) {
9327 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9328 }
9329 }
9330 impl Default for HuffencAc02 {
9331 #[inline(always)]
9332 fn default() -> HuffencAc02 {
9333 HuffencAc02(0)
9334 }
9335 }
9336 impl core::fmt::Debug for HuffencAc02 {
9337 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9338 f.debug_struct("HuffencAc02")
9339 .field("dhtmem_ram", &self.dhtmem_ram())
9340 .finish()
9341 }
9342 }
9343 #[cfg(feature = "defmt")]
9344 impl defmt::Format for HuffencAc02 {
9345 fn format(&self, f: defmt::Formatter) {
9346 #[derive(defmt :: Format)]
9347 struct HuffencAc02 {
9348 dhtmem_ram: u32,
9349 }
9350 let proxy = HuffencAc02 {
9351 dhtmem_ram: self.dhtmem_ram(),
9352 };
9353 defmt::write!(f, "{}", proxy)
9354 }
9355 }
9356 #[doc = "JPEG encoder, AC Huffman table 0"]
9357 #[repr(transparent)]
9358 #[derive(Copy, Clone, Eq, PartialEq)]
9359 pub struct HuffencAc020(pub u32);
9360 impl HuffencAc020 {
9361 #[doc = "DHTMem RAM"]
9362 #[inline(always)]
9363 pub const fn dhtmem_ram(&self) -> u32 {
9364 let val = (self.0 >> 0usize) & 0xffff_ffff;
9365 val as u32
9366 }
9367 #[doc = "DHTMem RAM"]
9368 #[inline(always)]
9369 pub fn set_dhtmem_ram(&mut self, val: u32) {
9370 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9371 }
9372 }
9373 impl Default for HuffencAc020 {
9374 #[inline(always)]
9375 fn default() -> HuffencAc020 {
9376 HuffencAc020(0)
9377 }
9378 }
9379 impl core::fmt::Debug for HuffencAc020 {
9380 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9381 f.debug_struct("HuffencAc020")
9382 .field("dhtmem_ram", &self.dhtmem_ram())
9383 .finish()
9384 }
9385 }
9386 #[cfg(feature = "defmt")]
9387 impl defmt::Format for HuffencAc020 {
9388 fn format(&self, f: defmt::Formatter) {
9389 #[derive(defmt :: Format)]
9390 struct HuffencAc020 {
9391 dhtmem_ram: u32,
9392 }
9393 let proxy = HuffencAc020 {
9394 dhtmem_ram: self.dhtmem_ram(),
9395 };
9396 defmt::write!(f, "{}", proxy)
9397 }
9398 }
9399 #[doc = "JPEG encoder, AC Huffman table 0"]
9400 #[repr(transparent)]
9401 #[derive(Copy, Clone, Eq, PartialEq)]
9402 pub struct HuffencAc021(pub u32);
9403 impl HuffencAc021 {
9404 #[doc = "DHTMem RAM"]
9405 #[inline(always)]
9406 pub const fn dhtmem_ram(&self) -> u32 {
9407 let val = (self.0 >> 0usize) & 0xffff_ffff;
9408 val as u32
9409 }
9410 #[doc = "DHTMem RAM"]
9411 #[inline(always)]
9412 pub fn set_dhtmem_ram(&mut self, val: u32) {
9413 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9414 }
9415 }
9416 impl Default for HuffencAc021 {
9417 #[inline(always)]
9418 fn default() -> HuffencAc021 {
9419 HuffencAc021(0)
9420 }
9421 }
9422 impl core::fmt::Debug for HuffencAc021 {
9423 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9424 f.debug_struct("HuffencAc021")
9425 .field("dhtmem_ram", &self.dhtmem_ram())
9426 .finish()
9427 }
9428 }
9429 #[cfg(feature = "defmt")]
9430 impl defmt::Format for HuffencAc021 {
9431 fn format(&self, f: defmt::Formatter) {
9432 #[derive(defmt :: Format)]
9433 struct HuffencAc021 {
9434 dhtmem_ram: u32,
9435 }
9436 let proxy = HuffencAc021 {
9437 dhtmem_ram: self.dhtmem_ram(),
9438 };
9439 defmt::write!(f, "{}", proxy)
9440 }
9441 }
9442 #[doc = "JPEG encoder, AC Huffman table 0"]
9443 #[repr(transparent)]
9444 #[derive(Copy, Clone, Eq, PartialEq)]
9445 pub struct HuffencAc022(pub u32);
9446 impl HuffencAc022 {
9447 #[doc = "DHTMem RAM"]
9448 #[inline(always)]
9449 pub const fn dhtmem_ram(&self) -> u32 {
9450 let val = (self.0 >> 0usize) & 0xffff_ffff;
9451 val as u32
9452 }
9453 #[doc = "DHTMem RAM"]
9454 #[inline(always)]
9455 pub fn set_dhtmem_ram(&mut self, val: u32) {
9456 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9457 }
9458 }
9459 impl Default for HuffencAc022 {
9460 #[inline(always)]
9461 fn default() -> HuffencAc022 {
9462 HuffencAc022(0)
9463 }
9464 }
9465 impl core::fmt::Debug for HuffencAc022 {
9466 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9467 f.debug_struct("HuffencAc022")
9468 .field("dhtmem_ram", &self.dhtmem_ram())
9469 .finish()
9470 }
9471 }
9472 #[cfg(feature = "defmt")]
9473 impl defmt::Format for HuffencAc022 {
9474 fn format(&self, f: defmt::Formatter) {
9475 #[derive(defmt :: Format)]
9476 struct HuffencAc022 {
9477 dhtmem_ram: u32,
9478 }
9479 let proxy = HuffencAc022 {
9480 dhtmem_ram: self.dhtmem_ram(),
9481 };
9482 defmt::write!(f, "{}", proxy)
9483 }
9484 }
9485 #[doc = "JPEG encoder, AC Huffman table 0"]
9486 #[repr(transparent)]
9487 #[derive(Copy, Clone, Eq, PartialEq)]
9488 pub struct HuffencAc023(pub u32);
9489 impl HuffencAc023 {
9490 #[doc = "DHTMem RAM"]
9491 #[inline(always)]
9492 pub const fn dhtmem_ram(&self) -> u32 {
9493 let val = (self.0 >> 0usize) & 0xffff_ffff;
9494 val as u32
9495 }
9496 #[doc = "DHTMem RAM"]
9497 #[inline(always)]
9498 pub fn set_dhtmem_ram(&mut self, val: u32) {
9499 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9500 }
9501 }
9502 impl Default for HuffencAc023 {
9503 #[inline(always)]
9504 fn default() -> HuffencAc023 {
9505 HuffencAc023(0)
9506 }
9507 }
9508 impl core::fmt::Debug for HuffencAc023 {
9509 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9510 f.debug_struct("HuffencAc023")
9511 .field("dhtmem_ram", &self.dhtmem_ram())
9512 .finish()
9513 }
9514 }
9515 #[cfg(feature = "defmt")]
9516 impl defmt::Format for HuffencAc023 {
9517 fn format(&self, f: defmt::Formatter) {
9518 #[derive(defmt :: Format)]
9519 struct HuffencAc023 {
9520 dhtmem_ram: u32,
9521 }
9522 let proxy = HuffencAc023 {
9523 dhtmem_ram: self.dhtmem_ram(),
9524 };
9525 defmt::write!(f, "{}", proxy)
9526 }
9527 }
9528 #[doc = "JPEG encoder, AC Huffman table 0"]
9529 #[repr(transparent)]
9530 #[derive(Copy, Clone, Eq, PartialEq)]
9531 pub struct HuffencAc024(pub u32);
9532 impl HuffencAc024 {
9533 #[doc = "DHTMem RAM"]
9534 #[inline(always)]
9535 pub const fn dhtmem_ram(&self) -> u32 {
9536 let val = (self.0 >> 0usize) & 0xffff_ffff;
9537 val as u32
9538 }
9539 #[doc = "DHTMem RAM"]
9540 #[inline(always)]
9541 pub fn set_dhtmem_ram(&mut self, val: u32) {
9542 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9543 }
9544 }
9545 impl Default for HuffencAc024 {
9546 #[inline(always)]
9547 fn default() -> HuffencAc024 {
9548 HuffencAc024(0)
9549 }
9550 }
9551 impl core::fmt::Debug for HuffencAc024 {
9552 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9553 f.debug_struct("HuffencAc024")
9554 .field("dhtmem_ram", &self.dhtmem_ram())
9555 .finish()
9556 }
9557 }
9558 #[cfg(feature = "defmt")]
9559 impl defmt::Format for HuffencAc024 {
9560 fn format(&self, f: defmt::Formatter) {
9561 #[derive(defmt :: Format)]
9562 struct HuffencAc024 {
9563 dhtmem_ram: u32,
9564 }
9565 let proxy = HuffencAc024 {
9566 dhtmem_ram: self.dhtmem_ram(),
9567 };
9568 defmt::write!(f, "{}", proxy)
9569 }
9570 }
9571 #[doc = "JPEG encoder, AC Huffman table 0"]
9572 #[repr(transparent)]
9573 #[derive(Copy, Clone, Eq, PartialEq)]
9574 pub struct HuffencAc025(pub u32);
9575 impl HuffencAc025 {
9576 #[doc = "DHTMem RAM"]
9577 #[inline(always)]
9578 pub const fn dhtmem_ram(&self) -> u32 {
9579 let val = (self.0 >> 0usize) & 0xffff_ffff;
9580 val as u32
9581 }
9582 #[doc = "DHTMem RAM"]
9583 #[inline(always)]
9584 pub fn set_dhtmem_ram(&mut self, val: u32) {
9585 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9586 }
9587 }
9588 impl Default for HuffencAc025 {
9589 #[inline(always)]
9590 fn default() -> HuffencAc025 {
9591 HuffencAc025(0)
9592 }
9593 }
9594 impl core::fmt::Debug for HuffencAc025 {
9595 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9596 f.debug_struct("HuffencAc025")
9597 .field("dhtmem_ram", &self.dhtmem_ram())
9598 .finish()
9599 }
9600 }
9601 #[cfg(feature = "defmt")]
9602 impl defmt::Format for HuffencAc025 {
9603 fn format(&self, f: defmt::Formatter) {
9604 #[derive(defmt :: Format)]
9605 struct HuffencAc025 {
9606 dhtmem_ram: u32,
9607 }
9608 let proxy = HuffencAc025 {
9609 dhtmem_ram: self.dhtmem_ram(),
9610 };
9611 defmt::write!(f, "{}", proxy)
9612 }
9613 }
9614 #[doc = "JPEG encoder, AC Huffman table 0"]
9615 #[repr(transparent)]
9616 #[derive(Copy, Clone, Eq, PartialEq)]
9617 pub struct HuffencAc026(pub u32);
9618 impl HuffencAc026 {
9619 #[doc = "DHTMem RAM"]
9620 #[inline(always)]
9621 pub const fn dhtmem_ram(&self) -> u32 {
9622 let val = (self.0 >> 0usize) & 0xffff_ffff;
9623 val as u32
9624 }
9625 #[doc = "DHTMem RAM"]
9626 #[inline(always)]
9627 pub fn set_dhtmem_ram(&mut self, val: u32) {
9628 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9629 }
9630 }
9631 impl Default for HuffencAc026 {
9632 #[inline(always)]
9633 fn default() -> HuffencAc026 {
9634 HuffencAc026(0)
9635 }
9636 }
9637 impl core::fmt::Debug for HuffencAc026 {
9638 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9639 f.debug_struct("HuffencAc026")
9640 .field("dhtmem_ram", &self.dhtmem_ram())
9641 .finish()
9642 }
9643 }
9644 #[cfg(feature = "defmt")]
9645 impl defmt::Format for HuffencAc026 {
9646 fn format(&self, f: defmt::Formatter) {
9647 #[derive(defmt :: Format)]
9648 struct HuffencAc026 {
9649 dhtmem_ram: u32,
9650 }
9651 let proxy = HuffencAc026 {
9652 dhtmem_ram: self.dhtmem_ram(),
9653 };
9654 defmt::write!(f, "{}", proxy)
9655 }
9656 }
9657 #[doc = "JPEG encoder, AC Huffman table 0"]
9658 #[repr(transparent)]
9659 #[derive(Copy, Clone, Eq, PartialEq)]
9660 pub struct HuffencAc027(pub u32);
9661 impl HuffencAc027 {
9662 #[doc = "DHTMem RAM"]
9663 #[inline(always)]
9664 pub const fn dhtmem_ram(&self) -> u32 {
9665 let val = (self.0 >> 0usize) & 0xffff_ffff;
9666 val as u32
9667 }
9668 #[doc = "DHTMem RAM"]
9669 #[inline(always)]
9670 pub fn set_dhtmem_ram(&mut self, val: u32) {
9671 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9672 }
9673 }
9674 impl Default for HuffencAc027 {
9675 #[inline(always)]
9676 fn default() -> HuffencAc027 {
9677 HuffencAc027(0)
9678 }
9679 }
9680 impl core::fmt::Debug for HuffencAc027 {
9681 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9682 f.debug_struct("HuffencAc027")
9683 .field("dhtmem_ram", &self.dhtmem_ram())
9684 .finish()
9685 }
9686 }
9687 #[cfg(feature = "defmt")]
9688 impl defmt::Format for HuffencAc027 {
9689 fn format(&self, f: defmt::Formatter) {
9690 #[derive(defmt :: Format)]
9691 struct HuffencAc027 {
9692 dhtmem_ram: u32,
9693 }
9694 let proxy = HuffencAc027 {
9695 dhtmem_ram: self.dhtmem_ram(),
9696 };
9697 defmt::write!(f, "{}", proxy)
9698 }
9699 }
9700 #[doc = "JPEG encoder, AC Huffman table 0"]
9701 #[repr(transparent)]
9702 #[derive(Copy, Clone, Eq, PartialEq)]
9703 pub struct HuffencAc028(pub u32);
9704 impl HuffencAc028 {
9705 #[doc = "DHTMem RAM"]
9706 #[inline(always)]
9707 pub const fn dhtmem_ram(&self) -> u32 {
9708 let val = (self.0 >> 0usize) & 0xffff_ffff;
9709 val as u32
9710 }
9711 #[doc = "DHTMem RAM"]
9712 #[inline(always)]
9713 pub fn set_dhtmem_ram(&mut self, val: u32) {
9714 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9715 }
9716 }
9717 impl Default for HuffencAc028 {
9718 #[inline(always)]
9719 fn default() -> HuffencAc028 {
9720 HuffencAc028(0)
9721 }
9722 }
9723 impl core::fmt::Debug for HuffencAc028 {
9724 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9725 f.debug_struct("HuffencAc028")
9726 .field("dhtmem_ram", &self.dhtmem_ram())
9727 .finish()
9728 }
9729 }
9730 #[cfg(feature = "defmt")]
9731 impl defmt::Format for HuffencAc028 {
9732 fn format(&self, f: defmt::Formatter) {
9733 #[derive(defmt :: Format)]
9734 struct HuffencAc028 {
9735 dhtmem_ram: u32,
9736 }
9737 let proxy = HuffencAc028 {
9738 dhtmem_ram: self.dhtmem_ram(),
9739 };
9740 defmt::write!(f, "{}", proxy)
9741 }
9742 }
9743 #[doc = "JPEG encoder, AC Huffman table 0"]
9744 #[repr(transparent)]
9745 #[derive(Copy, Clone, Eq, PartialEq)]
9746 pub struct HuffencAc029(pub u32);
9747 impl HuffencAc029 {
9748 #[doc = "DHTMem RAM"]
9749 #[inline(always)]
9750 pub const fn dhtmem_ram(&self) -> u32 {
9751 let val = (self.0 >> 0usize) & 0xffff_ffff;
9752 val as u32
9753 }
9754 #[doc = "DHTMem RAM"]
9755 #[inline(always)]
9756 pub fn set_dhtmem_ram(&mut self, val: u32) {
9757 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9758 }
9759 }
9760 impl Default for HuffencAc029 {
9761 #[inline(always)]
9762 fn default() -> HuffencAc029 {
9763 HuffencAc029(0)
9764 }
9765 }
9766 impl core::fmt::Debug for HuffencAc029 {
9767 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9768 f.debug_struct("HuffencAc029")
9769 .field("dhtmem_ram", &self.dhtmem_ram())
9770 .finish()
9771 }
9772 }
9773 #[cfg(feature = "defmt")]
9774 impl defmt::Format for HuffencAc029 {
9775 fn format(&self, f: defmt::Formatter) {
9776 #[derive(defmt :: Format)]
9777 struct HuffencAc029 {
9778 dhtmem_ram: u32,
9779 }
9780 let proxy = HuffencAc029 {
9781 dhtmem_ram: self.dhtmem_ram(),
9782 };
9783 defmt::write!(f, "{}", proxy)
9784 }
9785 }
9786 #[doc = "JPEG encoder, AC Huffman table 0"]
9787 #[repr(transparent)]
9788 #[derive(Copy, Clone, Eq, PartialEq)]
9789 pub struct HuffencAc03(pub u32);
9790 impl HuffencAc03 {
9791 #[doc = "DHTMem RAM"]
9792 #[inline(always)]
9793 pub const fn dhtmem_ram(&self) -> u32 {
9794 let val = (self.0 >> 0usize) & 0xffff_ffff;
9795 val as u32
9796 }
9797 #[doc = "DHTMem RAM"]
9798 #[inline(always)]
9799 pub fn set_dhtmem_ram(&mut self, val: u32) {
9800 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9801 }
9802 }
9803 impl Default for HuffencAc03 {
9804 #[inline(always)]
9805 fn default() -> HuffencAc03 {
9806 HuffencAc03(0)
9807 }
9808 }
9809 impl core::fmt::Debug for HuffencAc03 {
9810 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9811 f.debug_struct("HuffencAc03")
9812 .field("dhtmem_ram", &self.dhtmem_ram())
9813 .finish()
9814 }
9815 }
9816 #[cfg(feature = "defmt")]
9817 impl defmt::Format for HuffencAc03 {
9818 fn format(&self, f: defmt::Formatter) {
9819 #[derive(defmt :: Format)]
9820 struct HuffencAc03 {
9821 dhtmem_ram: u32,
9822 }
9823 let proxy = HuffencAc03 {
9824 dhtmem_ram: self.dhtmem_ram(),
9825 };
9826 defmt::write!(f, "{}", proxy)
9827 }
9828 }
9829 #[doc = "JPEG encoder, AC Huffman table 0"]
9830 #[repr(transparent)]
9831 #[derive(Copy, Clone, Eq, PartialEq)]
9832 pub struct HuffencAc030(pub u32);
9833 impl HuffencAc030 {
9834 #[doc = "DHTMem RAM"]
9835 #[inline(always)]
9836 pub const fn dhtmem_ram(&self) -> u32 {
9837 let val = (self.0 >> 0usize) & 0xffff_ffff;
9838 val as u32
9839 }
9840 #[doc = "DHTMem RAM"]
9841 #[inline(always)]
9842 pub fn set_dhtmem_ram(&mut self, val: u32) {
9843 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9844 }
9845 }
9846 impl Default for HuffencAc030 {
9847 #[inline(always)]
9848 fn default() -> HuffencAc030 {
9849 HuffencAc030(0)
9850 }
9851 }
9852 impl core::fmt::Debug for HuffencAc030 {
9853 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9854 f.debug_struct("HuffencAc030")
9855 .field("dhtmem_ram", &self.dhtmem_ram())
9856 .finish()
9857 }
9858 }
9859 #[cfg(feature = "defmt")]
9860 impl defmt::Format for HuffencAc030 {
9861 fn format(&self, f: defmt::Formatter) {
9862 #[derive(defmt :: Format)]
9863 struct HuffencAc030 {
9864 dhtmem_ram: u32,
9865 }
9866 let proxy = HuffencAc030 {
9867 dhtmem_ram: self.dhtmem_ram(),
9868 };
9869 defmt::write!(f, "{}", proxy)
9870 }
9871 }
9872 #[doc = "JPEG encoder, AC Huffman table 0"]
9873 #[repr(transparent)]
9874 #[derive(Copy, Clone, Eq, PartialEq)]
9875 pub struct HuffencAc031(pub u32);
9876 impl HuffencAc031 {
9877 #[doc = "DHTMem RAM"]
9878 #[inline(always)]
9879 pub const fn dhtmem_ram(&self) -> u32 {
9880 let val = (self.0 >> 0usize) & 0xffff_ffff;
9881 val as u32
9882 }
9883 #[doc = "DHTMem RAM"]
9884 #[inline(always)]
9885 pub fn set_dhtmem_ram(&mut self, val: u32) {
9886 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9887 }
9888 }
9889 impl Default for HuffencAc031 {
9890 #[inline(always)]
9891 fn default() -> HuffencAc031 {
9892 HuffencAc031(0)
9893 }
9894 }
9895 impl core::fmt::Debug for HuffencAc031 {
9896 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9897 f.debug_struct("HuffencAc031")
9898 .field("dhtmem_ram", &self.dhtmem_ram())
9899 .finish()
9900 }
9901 }
9902 #[cfg(feature = "defmt")]
9903 impl defmt::Format for HuffencAc031 {
9904 fn format(&self, f: defmt::Formatter) {
9905 #[derive(defmt :: Format)]
9906 struct HuffencAc031 {
9907 dhtmem_ram: u32,
9908 }
9909 let proxy = HuffencAc031 {
9910 dhtmem_ram: self.dhtmem_ram(),
9911 };
9912 defmt::write!(f, "{}", proxy)
9913 }
9914 }
9915 #[doc = "JPEG encoder, AC Huffman table 0"]
9916 #[repr(transparent)]
9917 #[derive(Copy, Clone, Eq, PartialEq)]
9918 pub struct HuffencAc032(pub u32);
9919 impl HuffencAc032 {
9920 #[doc = "DHTMem RAM"]
9921 #[inline(always)]
9922 pub const fn dhtmem_ram(&self) -> u32 {
9923 let val = (self.0 >> 0usize) & 0xffff_ffff;
9924 val as u32
9925 }
9926 #[doc = "DHTMem RAM"]
9927 #[inline(always)]
9928 pub fn set_dhtmem_ram(&mut self, val: u32) {
9929 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9930 }
9931 }
9932 impl Default for HuffencAc032 {
9933 #[inline(always)]
9934 fn default() -> HuffencAc032 {
9935 HuffencAc032(0)
9936 }
9937 }
9938 impl core::fmt::Debug for HuffencAc032 {
9939 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9940 f.debug_struct("HuffencAc032")
9941 .field("dhtmem_ram", &self.dhtmem_ram())
9942 .finish()
9943 }
9944 }
9945 #[cfg(feature = "defmt")]
9946 impl defmt::Format for HuffencAc032 {
9947 fn format(&self, f: defmt::Formatter) {
9948 #[derive(defmt :: Format)]
9949 struct HuffencAc032 {
9950 dhtmem_ram: u32,
9951 }
9952 let proxy = HuffencAc032 {
9953 dhtmem_ram: self.dhtmem_ram(),
9954 };
9955 defmt::write!(f, "{}", proxy)
9956 }
9957 }
9958 #[doc = "JPEG encoder, AC Huffman table 0"]
9959 #[repr(transparent)]
9960 #[derive(Copy, Clone, Eq, PartialEq)]
9961 pub struct HuffencAc033(pub u32);
9962 impl HuffencAc033 {
9963 #[doc = "DHTMem RAM"]
9964 #[inline(always)]
9965 pub const fn dhtmem_ram(&self) -> u32 {
9966 let val = (self.0 >> 0usize) & 0xffff_ffff;
9967 val as u32
9968 }
9969 #[doc = "DHTMem RAM"]
9970 #[inline(always)]
9971 pub fn set_dhtmem_ram(&mut self, val: u32) {
9972 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
9973 }
9974 }
9975 impl Default for HuffencAc033 {
9976 #[inline(always)]
9977 fn default() -> HuffencAc033 {
9978 HuffencAc033(0)
9979 }
9980 }
9981 impl core::fmt::Debug for HuffencAc033 {
9982 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
9983 f.debug_struct("HuffencAc033")
9984 .field("dhtmem_ram", &self.dhtmem_ram())
9985 .finish()
9986 }
9987 }
9988 #[cfg(feature = "defmt")]
9989 impl defmt::Format for HuffencAc033 {
9990 fn format(&self, f: defmt::Formatter) {
9991 #[derive(defmt :: Format)]
9992 struct HuffencAc033 {
9993 dhtmem_ram: u32,
9994 }
9995 let proxy = HuffencAc033 {
9996 dhtmem_ram: self.dhtmem_ram(),
9997 };
9998 defmt::write!(f, "{}", proxy)
9999 }
10000 }
10001 #[doc = "JPEG encoder, AC Huffman table 0"]
10002 #[repr(transparent)]
10003 #[derive(Copy, Clone, Eq, PartialEq)]
10004 pub struct HuffencAc034(pub u32);
10005 impl HuffencAc034 {
10006 #[doc = "DHTMem RAM"]
10007 #[inline(always)]
10008 pub const fn dhtmem_ram(&self) -> u32 {
10009 let val = (self.0 >> 0usize) & 0xffff_ffff;
10010 val as u32
10011 }
10012 #[doc = "DHTMem RAM"]
10013 #[inline(always)]
10014 pub fn set_dhtmem_ram(&mut self, val: u32) {
10015 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10016 }
10017 }
10018 impl Default for HuffencAc034 {
10019 #[inline(always)]
10020 fn default() -> HuffencAc034 {
10021 HuffencAc034(0)
10022 }
10023 }
10024 impl core::fmt::Debug for HuffencAc034 {
10025 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10026 f.debug_struct("HuffencAc034")
10027 .field("dhtmem_ram", &self.dhtmem_ram())
10028 .finish()
10029 }
10030 }
10031 #[cfg(feature = "defmt")]
10032 impl defmt::Format for HuffencAc034 {
10033 fn format(&self, f: defmt::Formatter) {
10034 #[derive(defmt :: Format)]
10035 struct HuffencAc034 {
10036 dhtmem_ram: u32,
10037 }
10038 let proxy = HuffencAc034 {
10039 dhtmem_ram: self.dhtmem_ram(),
10040 };
10041 defmt::write!(f, "{}", proxy)
10042 }
10043 }
10044 #[doc = "JPEG encoder, AC Huffman table 0"]
10045 #[repr(transparent)]
10046 #[derive(Copy, Clone, Eq, PartialEq)]
10047 pub struct HuffencAc035(pub u32);
10048 impl HuffencAc035 {
10049 #[doc = "DHTMem RAM"]
10050 #[inline(always)]
10051 pub const fn dhtmem_ram(&self) -> u32 {
10052 let val = (self.0 >> 0usize) & 0xffff_ffff;
10053 val as u32
10054 }
10055 #[doc = "DHTMem RAM"]
10056 #[inline(always)]
10057 pub fn set_dhtmem_ram(&mut self, val: u32) {
10058 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10059 }
10060 }
10061 impl Default for HuffencAc035 {
10062 #[inline(always)]
10063 fn default() -> HuffencAc035 {
10064 HuffencAc035(0)
10065 }
10066 }
10067 impl core::fmt::Debug for HuffencAc035 {
10068 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10069 f.debug_struct("HuffencAc035")
10070 .field("dhtmem_ram", &self.dhtmem_ram())
10071 .finish()
10072 }
10073 }
10074 #[cfg(feature = "defmt")]
10075 impl defmt::Format for HuffencAc035 {
10076 fn format(&self, f: defmt::Formatter) {
10077 #[derive(defmt :: Format)]
10078 struct HuffencAc035 {
10079 dhtmem_ram: u32,
10080 }
10081 let proxy = HuffencAc035 {
10082 dhtmem_ram: self.dhtmem_ram(),
10083 };
10084 defmt::write!(f, "{}", proxy)
10085 }
10086 }
10087 #[doc = "JPEG encoder, AC Huffman table 0"]
10088 #[repr(transparent)]
10089 #[derive(Copy, Clone, Eq, PartialEq)]
10090 pub struct HuffencAc036(pub u32);
10091 impl HuffencAc036 {
10092 #[doc = "DHTMem RAM"]
10093 #[inline(always)]
10094 pub const fn dhtmem_ram(&self) -> u32 {
10095 let val = (self.0 >> 0usize) & 0xffff_ffff;
10096 val as u32
10097 }
10098 #[doc = "DHTMem RAM"]
10099 #[inline(always)]
10100 pub fn set_dhtmem_ram(&mut self, val: u32) {
10101 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10102 }
10103 }
10104 impl Default for HuffencAc036 {
10105 #[inline(always)]
10106 fn default() -> HuffencAc036 {
10107 HuffencAc036(0)
10108 }
10109 }
10110 impl core::fmt::Debug for HuffencAc036 {
10111 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10112 f.debug_struct("HuffencAc036")
10113 .field("dhtmem_ram", &self.dhtmem_ram())
10114 .finish()
10115 }
10116 }
10117 #[cfg(feature = "defmt")]
10118 impl defmt::Format for HuffencAc036 {
10119 fn format(&self, f: defmt::Formatter) {
10120 #[derive(defmt :: Format)]
10121 struct HuffencAc036 {
10122 dhtmem_ram: u32,
10123 }
10124 let proxy = HuffencAc036 {
10125 dhtmem_ram: self.dhtmem_ram(),
10126 };
10127 defmt::write!(f, "{}", proxy)
10128 }
10129 }
10130 #[doc = "JPEG encoder, AC Huffman table 0"]
10131 #[repr(transparent)]
10132 #[derive(Copy, Clone, Eq, PartialEq)]
10133 pub struct HuffencAc037(pub u32);
10134 impl HuffencAc037 {
10135 #[doc = "DHTMem RAM"]
10136 #[inline(always)]
10137 pub const fn dhtmem_ram(&self) -> u32 {
10138 let val = (self.0 >> 0usize) & 0xffff_ffff;
10139 val as u32
10140 }
10141 #[doc = "DHTMem RAM"]
10142 #[inline(always)]
10143 pub fn set_dhtmem_ram(&mut self, val: u32) {
10144 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10145 }
10146 }
10147 impl Default for HuffencAc037 {
10148 #[inline(always)]
10149 fn default() -> HuffencAc037 {
10150 HuffencAc037(0)
10151 }
10152 }
10153 impl core::fmt::Debug for HuffencAc037 {
10154 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10155 f.debug_struct("HuffencAc037")
10156 .field("dhtmem_ram", &self.dhtmem_ram())
10157 .finish()
10158 }
10159 }
10160 #[cfg(feature = "defmt")]
10161 impl defmt::Format for HuffencAc037 {
10162 fn format(&self, f: defmt::Formatter) {
10163 #[derive(defmt :: Format)]
10164 struct HuffencAc037 {
10165 dhtmem_ram: u32,
10166 }
10167 let proxy = HuffencAc037 {
10168 dhtmem_ram: self.dhtmem_ram(),
10169 };
10170 defmt::write!(f, "{}", proxy)
10171 }
10172 }
10173 #[doc = "JPEG encoder, AC Huffman table 0"]
10174 #[repr(transparent)]
10175 #[derive(Copy, Clone, Eq, PartialEq)]
10176 pub struct HuffencAc038(pub u32);
10177 impl HuffencAc038 {
10178 #[doc = "DHTMem RAM"]
10179 #[inline(always)]
10180 pub const fn dhtmem_ram(&self) -> u32 {
10181 let val = (self.0 >> 0usize) & 0xffff_ffff;
10182 val as u32
10183 }
10184 #[doc = "DHTMem RAM"]
10185 #[inline(always)]
10186 pub fn set_dhtmem_ram(&mut self, val: u32) {
10187 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10188 }
10189 }
10190 impl Default for HuffencAc038 {
10191 #[inline(always)]
10192 fn default() -> HuffencAc038 {
10193 HuffencAc038(0)
10194 }
10195 }
10196 impl core::fmt::Debug for HuffencAc038 {
10197 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10198 f.debug_struct("HuffencAc038")
10199 .field("dhtmem_ram", &self.dhtmem_ram())
10200 .finish()
10201 }
10202 }
10203 #[cfg(feature = "defmt")]
10204 impl defmt::Format for HuffencAc038 {
10205 fn format(&self, f: defmt::Formatter) {
10206 #[derive(defmt :: Format)]
10207 struct HuffencAc038 {
10208 dhtmem_ram: u32,
10209 }
10210 let proxy = HuffencAc038 {
10211 dhtmem_ram: self.dhtmem_ram(),
10212 };
10213 defmt::write!(f, "{}", proxy)
10214 }
10215 }
10216 #[doc = "JPEG encoder, AC Huffman table 0"]
10217 #[repr(transparent)]
10218 #[derive(Copy, Clone, Eq, PartialEq)]
10219 pub struct HuffencAc039(pub u32);
10220 impl HuffencAc039 {
10221 #[doc = "DHTMem RAM"]
10222 #[inline(always)]
10223 pub const fn dhtmem_ram(&self) -> u32 {
10224 let val = (self.0 >> 0usize) & 0xffff_ffff;
10225 val as u32
10226 }
10227 #[doc = "DHTMem RAM"]
10228 #[inline(always)]
10229 pub fn set_dhtmem_ram(&mut self, val: u32) {
10230 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10231 }
10232 }
10233 impl Default for HuffencAc039 {
10234 #[inline(always)]
10235 fn default() -> HuffencAc039 {
10236 HuffencAc039(0)
10237 }
10238 }
10239 impl core::fmt::Debug for HuffencAc039 {
10240 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10241 f.debug_struct("HuffencAc039")
10242 .field("dhtmem_ram", &self.dhtmem_ram())
10243 .finish()
10244 }
10245 }
10246 #[cfg(feature = "defmt")]
10247 impl defmt::Format for HuffencAc039 {
10248 fn format(&self, f: defmt::Formatter) {
10249 #[derive(defmt :: Format)]
10250 struct HuffencAc039 {
10251 dhtmem_ram: u32,
10252 }
10253 let proxy = HuffencAc039 {
10254 dhtmem_ram: self.dhtmem_ram(),
10255 };
10256 defmt::write!(f, "{}", proxy)
10257 }
10258 }
10259 #[doc = "JPEG encoder, AC Huffman table 0"]
10260 #[repr(transparent)]
10261 #[derive(Copy, Clone, Eq, PartialEq)]
10262 pub struct HuffencAc04(pub u32);
10263 impl HuffencAc04 {
10264 #[doc = "DHTMem RAM"]
10265 #[inline(always)]
10266 pub const fn dhtmem_ram(&self) -> u32 {
10267 let val = (self.0 >> 0usize) & 0xffff_ffff;
10268 val as u32
10269 }
10270 #[doc = "DHTMem RAM"]
10271 #[inline(always)]
10272 pub fn set_dhtmem_ram(&mut self, val: u32) {
10273 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10274 }
10275 }
10276 impl Default for HuffencAc04 {
10277 #[inline(always)]
10278 fn default() -> HuffencAc04 {
10279 HuffencAc04(0)
10280 }
10281 }
10282 impl core::fmt::Debug for HuffencAc04 {
10283 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10284 f.debug_struct("HuffencAc04")
10285 .field("dhtmem_ram", &self.dhtmem_ram())
10286 .finish()
10287 }
10288 }
10289 #[cfg(feature = "defmt")]
10290 impl defmt::Format for HuffencAc04 {
10291 fn format(&self, f: defmt::Formatter) {
10292 #[derive(defmt :: Format)]
10293 struct HuffencAc04 {
10294 dhtmem_ram: u32,
10295 }
10296 let proxy = HuffencAc04 {
10297 dhtmem_ram: self.dhtmem_ram(),
10298 };
10299 defmt::write!(f, "{}", proxy)
10300 }
10301 }
10302 #[doc = "JPEG encoder, AC Huffman table 0"]
10303 #[repr(transparent)]
10304 #[derive(Copy, Clone, Eq, PartialEq)]
10305 pub struct HuffencAc040(pub u32);
10306 impl HuffencAc040 {
10307 #[doc = "DHTMem RAM"]
10308 #[inline(always)]
10309 pub const fn dhtmem_ram(&self) -> u32 {
10310 let val = (self.0 >> 0usize) & 0xffff_ffff;
10311 val as u32
10312 }
10313 #[doc = "DHTMem RAM"]
10314 #[inline(always)]
10315 pub fn set_dhtmem_ram(&mut self, val: u32) {
10316 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10317 }
10318 }
10319 impl Default for HuffencAc040 {
10320 #[inline(always)]
10321 fn default() -> HuffencAc040 {
10322 HuffencAc040(0)
10323 }
10324 }
10325 impl core::fmt::Debug for HuffencAc040 {
10326 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10327 f.debug_struct("HuffencAc040")
10328 .field("dhtmem_ram", &self.dhtmem_ram())
10329 .finish()
10330 }
10331 }
10332 #[cfg(feature = "defmt")]
10333 impl defmt::Format for HuffencAc040 {
10334 fn format(&self, f: defmt::Formatter) {
10335 #[derive(defmt :: Format)]
10336 struct HuffencAc040 {
10337 dhtmem_ram: u32,
10338 }
10339 let proxy = HuffencAc040 {
10340 dhtmem_ram: self.dhtmem_ram(),
10341 };
10342 defmt::write!(f, "{}", proxy)
10343 }
10344 }
10345 #[doc = "JPEG encoder, AC Huffman table 0"]
10346 #[repr(transparent)]
10347 #[derive(Copy, Clone, Eq, PartialEq)]
10348 pub struct HuffencAc041(pub u32);
10349 impl HuffencAc041 {
10350 #[doc = "DHTMem RAM"]
10351 #[inline(always)]
10352 pub const fn dhtmem_ram(&self) -> u32 {
10353 let val = (self.0 >> 0usize) & 0xffff_ffff;
10354 val as u32
10355 }
10356 #[doc = "DHTMem RAM"]
10357 #[inline(always)]
10358 pub fn set_dhtmem_ram(&mut self, val: u32) {
10359 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10360 }
10361 }
10362 impl Default for HuffencAc041 {
10363 #[inline(always)]
10364 fn default() -> HuffencAc041 {
10365 HuffencAc041(0)
10366 }
10367 }
10368 impl core::fmt::Debug for HuffencAc041 {
10369 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10370 f.debug_struct("HuffencAc041")
10371 .field("dhtmem_ram", &self.dhtmem_ram())
10372 .finish()
10373 }
10374 }
10375 #[cfg(feature = "defmt")]
10376 impl defmt::Format for HuffencAc041 {
10377 fn format(&self, f: defmt::Formatter) {
10378 #[derive(defmt :: Format)]
10379 struct HuffencAc041 {
10380 dhtmem_ram: u32,
10381 }
10382 let proxy = HuffencAc041 {
10383 dhtmem_ram: self.dhtmem_ram(),
10384 };
10385 defmt::write!(f, "{}", proxy)
10386 }
10387 }
10388 #[doc = "JPEG encoder, AC Huffman table 0"]
10389 #[repr(transparent)]
10390 #[derive(Copy, Clone, Eq, PartialEq)]
10391 pub struct HuffencAc042(pub u32);
10392 impl HuffencAc042 {
10393 #[doc = "DHTMem RAM"]
10394 #[inline(always)]
10395 pub const fn dhtmem_ram(&self) -> u32 {
10396 let val = (self.0 >> 0usize) & 0xffff_ffff;
10397 val as u32
10398 }
10399 #[doc = "DHTMem RAM"]
10400 #[inline(always)]
10401 pub fn set_dhtmem_ram(&mut self, val: u32) {
10402 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10403 }
10404 }
10405 impl Default for HuffencAc042 {
10406 #[inline(always)]
10407 fn default() -> HuffencAc042 {
10408 HuffencAc042(0)
10409 }
10410 }
10411 impl core::fmt::Debug for HuffencAc042 {
10412 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10413 f.debug_struct("HuffencAc042")
10414 .field("dhtmem_ram", &self.dhtmem_ram())
10415 .finish()
10416 }
10417 }
10418 #[cfg(feature = "defmt")]
10419 impl defmt::Format for HuffencAc042 {
10420 fn format(&self, f: defmt::Formatter) {
10421 #[derive(defmt :: Format)]
10422 struct HuffencAc042 {
10423 dhtmem_ram: u32,
10424 }
10425 let proxy = HuffencAc042 {
10426 dhtmem_ram: self.dhtmem_ram(),
10427 };
10428 defmt::write!(f, "{}", proxy)
10429 }
10430 }
10431 #[doc = "JPEG encoder, AC Huffman table 0"]
10432 #[repr(transparent)]
10433 #[derive(Copy, Clone, Eq, PartialEq)]
10434 pub struct HuffencAc043(pub u32);
10435 impl HuffencAc043 {
10436 #[doc = "DHTMem RAM"]
10437 #[inline(always)]
10438 pub const fn dhtmem_ram(&self) -> u32 {
10439 let val = (self.0 >> 0usize) & 0xffff_ffff;
10440 val as u32
10441 }
10442 #[doc = "DHTMem RAM"]
10443 #[inline(always)]
10444 pub fn set_dhtmem_ram(&mut self, val: u32) {
10445 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10446 }
10447 }
10448 impl Default for HuffencAc043 {
10449 #[inline(always)]
10450 fn default() -> HuffencAc043 {
10451 HuffencAc043(0)
10452 }
10453 }
10454 impl core::fmt::Debug for HuffencAc043 {
10455 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10456 f.debug_struct("HuffencAc043")
10457 .field("dhtmem_ram", &self.dhtmem_ram())
10458 .finish()
10459 }
10460 }
10461 #[cfg(feature = "defmt")]
10462 impl defmt::Format for HuffencAc043 {
10463 fn format(&self, f: defmt::Formatter) {
10464 #[derive(defmt :: Format)]
10465 struct HuffencAc043 {
10466 dhtmem_ram: u32,
10467 }
10468 let proxy = HuffencAc043 {
10469 dhtmem_ram: self.dhtmem_ram(),
10470 };
10471 defmt::write!(f, "{}", proxy)
10472 }
10473 }
10474 #[doc = "JPEG encoder, AC Huffman table 0"]
10475 #[repr(transparent)]
10476 #[derive(Copy, Clone, Eq, PartialEq)]
10477 pub struct HuffencAc044(pub u32);
10478 impl HuffencAc044 {
10479 #[doc = "DHTMem RAM"]
10480 #[inline(always)]
10481 pub const fn dhtmem_ram(&self) -> u32 {
10482 let val = (self.0 >> 0usize) & 0xffff_ffff;
10483 val as u32
10484 }
10485 #[doc = "DHTMem RAM"]
10486 #[inline(always)]
10487 pub fn set_dhtmem_ram(&mut self, val: u32) {
10488 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10489 }
10490 }
10491 impl Default for HuffencAc044 {
10492 #[inline(always)]
10493 fn default() -> HuffencAc044 {
10494 HuffencAc044(0)
10495 }
10496 }
10497 impl core::fmt::Debug for HuffencAc044 {
10498 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10499 f.debug_struct("HuffencAc044")
10500 .field("dhtmem_ram", &self.dhtmem_ram())
10501 .finish()
10502 }
10503 }
10504 #[cfg(feature = "defmt")]
10505 impl defmt::Format for HuffencAc044 {
10506 fn format(&self, f: defmt::Formatter) {
10507 #[derive(defmt :: Format)]
10508 struct HuffencAc044 {
10509 dhtmem_ram: u32,
10510 }
10511 let proxy = HuffencAc044 {
10512 dhtmem_ram: self.dhtmem_ram(),
10513 };
10514 defmt::write!(f, "{}", proxy)
10515 }
10516 }
10517 #[doc = "JPEG encoder, AC Huffman table 0"]
10518 #[repr(transparent)]
10519 #[derive(Copy, Clone, Eq, PartialEq)]
10520 pub struct HuffencAc045(pub u32);
10521 impl HuffencAc045 {
10522 #[doc = "DHTMem RAM"]
10523 #[inline(always)]
10524 pub const fn dhtmem_ram(&self) -> u32 {
10525 let val = (self.0 >> 0usize) & 0xffff_ffff;
10526 val as u32
10527 }
10528 #[doc = "DHTMem RAM"]
10529 #[inline(always)]
10530 pub fn set_dhtmem_ram(&mut self, val: u32) {
10531 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10532 }
10533 }
10534 impl Default for HuffencAc045 {
10535 #[inline(always)]
10536 fn default() -> HuffencAc045 {
10537 HuffencAc045(0)
10538 }
10539 }
10540 impl core::fmt::Debug for HuffencAc045 {
10541 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10542 f.debug_struct("HuffencAc045")
10543 .field("dhtmem_ram", &self.dhtmem_ram())
10544 .finish()
10545 }
10546 }
10547 #[cfg(feature = "defmt")]
10548 impl defmt::Format for HuffencAc045 {
10549 fn format(&self, f: defmt::Formatter) {
10550 #[derive(defmt :: Format)]
10551 struct HuffencAc045 {
10552 dhtmem_ram: u32,
10553 }
10554 let proxy = HuffencAc045 {
10555 dhtmem_ram: self.dhtmem_ram(),
10556 };
10557 defmt::write!(f, "{}", proxy)
10558 }
10559 }
10560 #[doc = "JPEG encoder, AC Huffman table 0"]
10561 #[repr(transparent)]
10562 #[derive(Copy, Clone, Eq, PartialEq)]
10563 pub struct HuffencAc046(pub u32);
10564 impl HuffencAc046 {
10565 #[doc = "DHTMem RAM"]
10566 #[inline(always)]
10567 pub const fn dhtmem_ram(&self) -> u32 {
10568 let val = (self.0 >> 0usize) & 0xffff_ffff;
10569 val as u32
10570 }
10571 #[doc = "DHTMem RAM"]
10572 #[inline(always)]
10573 pub fn set_dhtmem_ram(&mut self, val: u32) {
10574 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10575 }
10576 }
10577 impl Default for HuffencAc046 {
10578 #[inline(always)]
10579 fn default() -> HuffencAc046 {
10580 HuffencAc046(0)
10581 }
10582 }
10583 impl core::fmt::Debug for HuffencAc046 {
10584 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10585 f.debug_struct("HuffencAc046")
10586 .field("dhtmem_ram", &self.dhtmem_ram())
10587 .finish()
10588 }
10589 }
10590 #[cfg(feature = "defmt")]
10591 impl defmt::Format for HuffencAc046 {
10592 fn format(&self, f: defmt::Formatter) {
10593 #[derive(defmt :: Format)]
10594 struct HuffencAc046 {
10595 dhtmem_ram: u32,
10596 }
10597 let proxy = HuffencAc046 {
10598 dhtmem_ram: self.dhtmem_ram(),
10599 };
10600 defmt::write!(f, "{}", proxy)
10601 }
10602 }
10603 #[doc = "JPEG encoder, AC Huffman table 0"]
10604 #[repr(transparent)]
10605 #[derive(Copy, Clone, Eq, PartialEq)]
10606 pub struct HuffencAc047(pub u32);
10607 impl HuffencAc047 {
10608 #[doc = "DHTMem RAM"]
10609 #[inline(always)]
10610 pub const fn dhtmem_ram(&self) -> u32 {
10611 let val = (self.0 >> 0usize) & 0xffff_ffff;
10612 val as u32
10613 }
10614 #[doc = "DHTMem RAM"]
10615 #[inline(always)]
10616 pub fn set_dhtmem_ram(&mut self, val: u32) {
10617 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10618 }
10619 }
10620 impl Default for HuffencAc047 {
10621 #[inline(always)]
10622 fn default() -> HuffencAc047 {
10623 HuffencAc047(0)
10624 }
10625 }
10626 impl core::fmt::Debug for HuffencAc047 {
10627 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10628 f.debug_struct("HuffencAc047")
10629 .field("dhtmem_ram", &self.dhtmem_ram())
10630 .finish()
10631 }
10632 }
10633 #[cfg(feature = "defmt")]
10634 impl defmt::Format for HuffencAc047 {
10635 fn format(&self, f: defmt::Formatter) {
10636 #[derive(defmt :: Format)]
10637 struct HuffencAc047 {
10638 dhtmem_ram: u32,
10639 }
10640 let proxy = HuffencAc047 {
10641 dhtmem_ram: self.dhtmem_ram(),
10642 };
10643 defmt::write!(f, "{}", proxy)
10644 }
10645 }
10646 #[doc = "JPEG encoder, AC Huffman table 0"]
10647 #[repr(transparent)]
10648 #[derive(Copy, Clone, Eq, PartialEq)]
10649 pub struct HuffencAc048(pub u32);
10650 impl HuffencAc048 {
10651 #[doc = "DHTMem RAM"]
10652 #[inline(always)]
10653 pub const fn dhtmem_ram(&self) -> u32 {
10654 let val = (self.0 >> 0usize) & 0xffff_ffff;
10655 val as u32
10656 }
10657 #[doc = "DHTMem RAM"]
10658 #[inline(always)]
10659 pub fn set_dhtmem_ram(&mut self, val: u32) {
10660 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10661 }
10662 }
10663 impl Default for HuffencAc048 {
10664 #[inline(always)]
10665 fn default() -> HuffencAc048 {
10666 HuffencAc048(0)
10667 }
10668 }
10669 impl core::fmt::Debug for HuffencAc048 {
10670 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10671 f.debug_struct("HuffencAc048")
10672 .field("dhtmem_ram", &self.dhtmem_ram())
10673 .finish()
10674 }
10675 }
10676 #[cfg(feature = "defmt")]
10677 impl defmt::Format for HuffencAc048 {
10678 fn format(&self, f: defmt::Formatter) {
10679 #[derive(defmt :: Format)]
10680 struct HuffencAc048 {
10681 dhtmem_ram: u32,
10682 }
10683 let proxy = HuffencAc048 {
10684 dhtmem_ram: self.dhtmem_ram(),
10685 };
10686 defmt::write!(f, "{}", proxy)
10687 }
10688 }
10689 #[doc = "JPEG encoder, AC Huffman table 0"]
10690 #[repr(transparent)]
10691 #[derive(Copy, Clone, Eq, PartialEq)]
10692 pub struct HuffencAc049(pub u32);
10693 impl HuffencAc049 {
10694 #[doc = "DHTMem RAM"]
10695 #[inline(always)]
10696 pub const fn dhtmem_ram(&self) -> u32 {
10697 let val = (self.0 >> 0usize) & 0xffff_ffff;
10698 val as u32
10699 }
10700 #[doc = "DHTMem RAM"]
10701 #[inline(always)]
10702 pub fn set_dhtmem_ram(&mut self, val: u32) {
10703 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10704 }
10705 }
10706 impl Default for HuffencAc049 {
10707 #[inline(always)]
10708 fn default() -> HuffencAc049 {
10709 HuffencAc049(0)
10710 }
10711 }
10712 impl core::fmt::Debug for HuffencAc049 {
10713 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10714 f.debug_struct("HuffencAc049")
10715 .field("dhtmem_ram", &self.dhtmem_ram())
10716 .finish()
10717 }
10718 }
10719 #[cfg(feature = "defmt")]
10720 impl defmt::Format for HuffencAc049 {
10721 fn format(&self, f: defmt::Formatter) {
10722 #[derive(defmt :: Format)]
10723 struct HuffencAc049 {
10724 dhtmem_ram: u32,
10725 }
10726 let proxy = HuffencAc049 {
10727 dhtmem_ram: self.dhtmem_ram(),
10728 };
10729 defmt::write!(f, "{}", proxy)
10730 }
10731 }
10732 #[doc = "JPEG encoder, AC Huffman table 0"]
10733 #[repr(transparent)]
10734 #[derive(Copy, Clone, Eq, PartialEq)]
10735 pub struct HuffencAc05(pub u32);
10736 impl HuffencAc05 {
10737 #[doc = "DHTMem RAM"]
10738 #[inline(always)]
10739 pub const fn dhtmem_ram(&self) -> u32 {
10740 let val = (self.0 >> 0usize) & 0xffff_ffff;
10741 val as u32
10742 }
10743 #[doc = "DHTMem RAM"]
10744 #[inline(always)]
10745 pub fn set_dhtmem_ram(&mut self, val: u32) {
10746 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10747 }
10748 }
10749 impl Default for HuffencAc05 {
10750 #[inline(always)]
10751 fn default() -> HuffencAc05 {
10752 HuffencAc05(0)
10753 }
10754 }
10755 impl core::fmt::Debug for HuffencAc05 {
10756 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10757 f.debug_struct("HuffencAc05")
10758 .field("dhtmem_ram", &self.dhtmem_ram())
10759 .finish()
10760 }
10761 }
10762 #[cfg(feature = "defmt")]
10763 impl defmt::Format for HuffencAc05 {
10764 fn format(&self, f: defmt::Formatter) {
10765 #[derive(defmt :: Format)]
10766 struct HuffencAc05 {
10767 dhtmem_ram: u32,
10768 }
10769 let proxy = HuffencAc05 {
10770 dhtmem_ram: self.dhtmem_ram(),
10771 };
10772 defmt::write!(f, "{}", proxy)
10773 }
10774 }
10775 #[doc = "JPEG encoder, AC Huffman table 0"]
10776 #[repr(transparent)]
10777 #[derive(Copy, Clone, Eq, PartialEq)]
10778 pub struct HuffencAc050(pub u32);
10779 impl HuffencAc050 {
10780 #[doc = "DHTMem RAM"]
10781 #[inline(always)]
10782 pub const fn dhtmem_ram(&self) -> u32 {
10783 let val = (self.0 >> 0usize) & 0xffff_ffff;
10784 val as u32
10785 }
10786 #[doc = "DHTMem RAM"]
10787 #[inline(always)]
10788 pub fn set_dhtmem_ram(&mut self, val: u32) {
10789 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10790 }
10791 }
10792 impl Default for HuffencAc050 {
10793 #[inline(always)]
10794 fn default() -> HuffencAc050 {
10795 HuffencAc050(0)
10796 }
10797 }
10798 impl core::fmt::Debug for HuffencAc050 {
10799 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10800 f.debug_struct("HuffencAc050")
10801 .field("dhtmem_ram", &self.dhtmem_ram())
10802 .finish()
10803 }
10804 }
10805 #[cfg(feature = "defmt")]
10806 impl defmt::Format for HuffencAc050 {
10807 fn format(&self, f: defmt::Formatter) {
10808 #[derive(defmt :: Format)]
10809 struct HuffencAc050 {
10810 dhtmem_ram: u32,
10811 }
10812 let proxy = HuffencAc050 {
10813 dhtmem_ram: self.dhtmem_ram(),
10814 };
10815 defmt::write!(f, "{}", proxy)
10816 }
10817 }
10818 #[doc = "JPEG encoder, AC Huffman table 0"]
10819 #[repr(transparent)]
10820 #[derive(Copy, Clone, Eq, PartialEq)]
10821 pub struct HuffencAc051(pub u32);
10822 impl HuffencAc051 {
10823 #[doc = "DHTMem RAM"]
10824 #[inline(always)]
10825 pub const fn dhtmem_ram(&self) -> u32 {
10826 let val = (self.0 >> 0usize) & 0xffff_ffff;
10827 val as u32
10828 }
10829 #[doc = "DHTMem RAM"]
10830 #[inline(always)]
10831 pub fn set_dhtmem_ram(&mut self, val: u32) {
10832 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10833 }
10834 }
10835 impl Default for HuffencAc051 {
10836 #[inline(always)]
10837 fn default() -> HuffencAc051 {
10838 HuffencAc051(0)
10839 }
10840 }
10841 impl core::fmt::Debug for HuffencAc051 {
10842 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10843 f.debug_struct("HuffencAc051")
10844 .field("dhtmem_ram", &self.dhtmem_ram())
10845 .finish()
10846 }
10847 }
10848 #[cfg(feature = "defmt")]
10849 impl defmt::Format for HuffencAc051 {
10850 fn format(&self, f: defmt::Formatter) {
10851 #[derive(defmt :: Format)]
10852 struct HuffencAc051 {
10853 dhtmem_ram: u32,
10854 }
10855 let proxy = HuffencAc051 {
10856 dhtmem_ram: self.dhtmem_ram(),
10857 };
10858 defmt::write!(f, "{}", proxy)
10859 }
10860 }
10861 #[doc = "JPEG encoder, AC Huffman table 0"]
10862 #[repr(transparent)]
10863 #[derive(Copy, Clone, Eq, PartialEq)]
10864 pub struct HuffencAc052(pub u32);
10865 impl HuffencAc052 {
10866 #[doc = "DHTMem RAM"]
10867 #[inline(always)]
10868 pub const fn dhtmem_ram(&self) -> u32 {
10869 let val = (self.0 >> 0usize) & 0xffff_ffff;
10870 val as u32
10871 }
10872 #[doc = "DHTMem RAM"]
10873 #[inline(always)]
10874 pub fn set_dhtmem_ram(&mut self, val: u32) {
10875 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10876 }
10877 }
10878 impl Default for HuffencAc052 {
10879 #[inline(always)]
10880 fn default() -> HuffencAc052 {
10881 HuffencAc052(0)
10882 }
10883 }
10884 impl core::fmt::Debug for HuffencAc052 {
10885 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10886 f.debug_struct("HuffencAc052")
10887 .field("dhtmem_ram", &self.dhtmem_ram())
10888 .finish()
10889 }
10890 }
10891 #[cfg(feature = "defmt")]
10892 impl defmt::Format for HuffencAc052 {
10893 fn format(&self, f: defmt::Formatter) {
10894 #[derive(defmt :: Format)]
10895 struct HuffencAc052 {
10896 dhtmem_ram: u32,
10897 }
10898 let proxy = HuffencAc052 {
10899 dhtmem_ram: self.dhtmem_ram(),
10900 };
10901 defmt::write!(f, "{}", proxy)
10902 }
10903 }
10904 #[doc = "JPEG encoder, AC Huffman table 0"]
10905 #[repr(transparent)]
10906 #[derive(Copy, Clone, Eq, PartialEq)]
10907 pub struct HuffencAc053(pub u32);
10908 impl HuffencAc053 {
10909 #[doc = "DHTMem RAM"]
10910 #[inline(always)]
10911 pub const fn dhtmem_ram(&self) -> u32 {
10912 let val = (self.0 >> 0usize) & 0xffff_ffff;
10913 val as u32
10914 }
10915 #[doc = "DHTMem RAM"]
10916 #[inline(always)]
10917 pub fn set_dhtmem_ram(&mut self, val: u32) {
10918 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10919 }
10920 }
10921 impl Default for HuffencAc053 {
10922 #[inline(always)]
10923 fn default() -> HuffencAc053 {
10924 HuffencAc053(0)
10925 }
10926 }
10927 impl core::fmt::Debug for HuffencAc053 {
10928 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10929 f.debug_struct("HuffencAc053")
10930 .field("dhtmem_ram", &self.dhtmem_ram())
10931 .finish()
10932 }
10933 }
10934 #[cfg(feature = "defmt")]
10935 impl defmt::Format for HuffencAc053 {
10936 fn format(&self, f: defmt::Formatter) {
10937 #[derive(defmt :: Format)]
10938 struct HuffencAc053 {
10939 dhtmem_ram: u32,
10940 }
10941 let proxy = HuffencAc053 {
10942 dhtmem_ram: self.dhtmem_ram(),
10943 };
10944 defmt::write!(f, "{}", proxy)
10945 }
10946 }
10947 #[doc = "JPEG encoder, AC Huffman table 0"]
10948 #[repr(transparent)]
10949 #[derive(Copy, Clone, Eq, PartialEq)]
10950 pub struct HuffencAc054(pub u32);
10951 impl HuffencAc054 {
10952 #[doc = "DHTMem RAM"]
10953 #[inline(always)]
10954 pub const fn dhtmem_ram(&self) -> u32 {
10955 let val = (self.0 >> 0usize) & 0xffff_ffff;
10956 val as u32
10957 }
10958 #[doc = "DHTMem RAM"]
10959 #[inline(always)]
10960 pub fn set_dhtmem_ram(&mut self, val: u32) {
10961 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
10962 }
10963 }
10964 impl Default for HuffencAc054 {
10965 #[inline(always)]
10966 fn default() -> HuffencAc054 {
10967 HuffencAc054(0)
10968 }
10969 }
10970 impl core::fmt::Debug for HuffencAc054 {
10971 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
10972 f.debug_struct("HuffencAc054")
10973 .field("dhtmem_ram", &self.dhtmem_ram())
10974 .finish()
10975 }
10976 }
10977 #[cfg(feature = "defmt")]
10978 impl defmt::Format for HuffencAc054 {
10979 fn format(&self, f: defmt::Formatter) {
10980 #[derive(defmt :: Format)]
10981 struct HuffencAc054 {
10982 dhtmem_ram: u32,
10983 }
10984 let proxy = HuffencAc054 {
10985 dhtmem_ram: self.dhtmem_ram(),
10986 };
10987 defmt::write!(f, "{}", proxy)
10988 }
10989 }
10990 #[doc = "JPEG encoder, AC Huffman table 0"]
10991 #[repr(transparent)]
10992 #[derive(Copy, Clone, Eq, PartialEq)]
10993 pub struct HuffencAc055(pub u32);
10994 impl HuffencAc055 {
10995 #[doc = "DHTMem RAM"]
10996 #[inline(always)]
10997 pub const fn dhtmem_ram(&self) -> u32 {
10998 let val = (self.0 >> 0usize) & 0xffff_ffff;
10999 val as u32
11000 }
11001 #[doc = "DHTMem RAM"]
11002 #[inline(always)]
11003 pub fn set_dhtmem_ram(&mut self, val: u32) {
11004 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11005 }
11006 }
11007 impl Default for HuffencAc055 {
11008 #[inline(always)]
11009 fn default() -> HuffencAc055 {
11010 HuffencAc055(0)
11011 }
11012 }
11013 impl core::fmt::Debug for HuffencAc055 {
11014 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11015 f.debug_struct("HuffencAc055")
11016 .field("dhtmem_ram", &self.dhtmem_ram())
11017 .finish()
11018 }
11019 }
11020 #[cfg(feature = "defmt")]
11021 impl defmt::Format for HuffencAc055 {
11022 fn format(&self, f: defmt::Formatter) {
11023 #[derive(defmt :: Format)]
11024 struct HuffencAc055 {
11025 dhtmem_ram: u32,
11026 }
11027 let proxy = HuffencAc055 {
11028 dhtmem_ram: self.dhtmem_ram(),
11029 };
11030 defmt::write!(f, "{}", proxy)
11031 }
11032 }
11033 #[doc = "JPEG encoder, AC Huffman table 0"]
11034 #[repr(transparent)]
11035 #[derive(Copy, Clone, Eq, PartialEq)]
11036 pub struct HuffencAc056(pub u32);
11037 impl HuffencAc056 {
11038 #[doc = "DHTMem RAM"]
11039 #[inline(always)]
11040 pub const fn dhtmem_ram(&self) -> u32 {
11041 let val = (self.0 >> 0usize) & 0xffff_ffff;
11042 val as u32
11043 }
11044 #[doc = "DHTMem RAM"]
11045 #[inline(always)]
11046 pub fn set_dhtmem_ram(&mut self, val: u32) {
11047 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11048 }
11049 }
11050 impl Default for HuffencAc056 {
11051 #[inline(always)]
11052 fn default() -> HuffencAc056 {
11053 HuffencAc056(0)
11054 }
11055 }
11056 impl core::fmt::Debug for HuffencAc056 {
11057 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11058 f.debug_struct("HuffencAc056")
11059 .field("dhtmem_ram", &self.dhtmem_ram())
11060 .finish()
11061 }
11062 }
11063 #[cfg(feature = "defmt")]
11064 impl defmt::Format for HuffencAc056 {
11065 fn format(&self, f: defmt::Formatter) {
11066 #[derive(defmt :: Format)]
11067 struct HuffencAc056 {
11068 dhtmem_ram: u32,
11069 }
11070 let proxy = HuffencAc056 {
11071 dhtmem_ram: self.dhtmem_ram(),
11072 };
11073 defmt::write!(f, "{}", proxy)
11074 }
11075 }
11076 #[doc = "JPEG encoder, AC Huffman table 0"]
11077 #[repr(transparent)]
11078 #[derive(Copy, Clone, Eq, PartialEq)]
11079 pub struct HuffencAc057(pub u32);
11080 impl HuffencAc057 {
11081 #[doc = "DHTMem RAM"]
11082 #[inline(always)]
11083 pub const fn dhtmem_ram(&self) -> u32 {
11084 let val = (self.0 >> 0usize) & 0xffff_ffff;
11085 val as u32
11086 }
11087 #[doc = "DHTMem RAM"]
11088 #[inline(always)]
11089 pub fn set_dhtmem_ram(&mut self, val: u32) {
11090 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11091 }
11092 }
11093 impl Default for HuffencAc057 {
11094 #[inline(always)]
11095 fn default() -> HuffencAc057 {
11096 HuffencAc057(0)
11097 }
11098 }
11099 impl core::fmt::Debug for HuffencAc057 {
11100 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11101 f.debug_struct("HuffencAc057")
11102 .field("dhtmem_ram", &self.dhtmem_ram())
11103 .finish()
11104 }
11105 }
11106 #[cfg(feature = "defmt")]
11107 impl defmt::Format for HuffencAc057 {
11108 fn format(&self, f: defmt::Formatter) {
11109 #[derive(defmt :: Format)]
11110 struct HuffencAc057 {
11111 dhtmem_ram: u32,
11112 }
11113 let proxy = HuffencAc057 {
11114 dhtmem_ram: self.dhtmem_ram(),
11115 };
11116 defmt::write!(f, "{}", proxy)
11117 }
11118 }
11119 #[doc = "JPEG encoder, AC Huffman table 0"]
11120 #[repr(transparent)]
11121 #[derive(Copy, Clone, Eq, PartialEq)]
11122 pub struct HuffencAc058(pub u32);
11123 impl HuffencAc058 {
11124 #[doc = "DHTMem RAM"]
11125 #[inline(always)]
11126 pub const fn dhtmem_ram(&self) -> u32 {
11127 let val = (self.0 >> 0usize) & 0xffff_ffff;
11128 val as u32
11129 }
11130 #[doc = "DHTMem RAM"]
11131 #[inline(always)]
11132 pub fn set_dhtmem_ram(&mut self, val: u32) {
11133 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11134 }
11135 }
11136 impl Default for HuffencAc058 {
11137 #[inline(always)]
11138 fn default() -> HuffencAc058 {
11139 HuffencAc058(0)
11140 }
11141 }
11142 impl core::fmt::Debug for HuffencAc058 {
11143 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11144 f.debug_struct("HuffencAc058")
11145 .field("dhtmem_ram", &self.dhtmem_ram())
11146 .finish()
11147 }
11148 }
11149 #[cfg(feature = "defmt")]
11150 impl defmt::Format for HuffencAc058 {
11151 fn format(&self, f: defmt::Formatter) {
11152 #[derive(defmt :: Format)]
11153 struct HuffencAc058 {
11154 dhtmem_ram: u32,
11155 }
11156 let proxy = HuffencAc058 {
11157 dhtmem_ram: self.dhtmem_ram(),
11158 };
11159 defmt::write!(f, "{}", proxy)
11160 }
11161 }
11162 #[doc = "JPEG encoder, AC Huffman table 0"]
11163 #[repr(transparent)]
11164 #[derive(Copy, Clone, Eq, PartialEq)]
11165 pub struct HuffencAc059(pub u32);
11166 impl HuffencAc059 {
11167 #[doc = "DHTMem RAM"]
11168 #[inline(always)]
11169 pub const fn dhtmem_ram(&self) -> u32 {
11170 let val = (self.0 >> 0usize) & 0xffff_ffff;
11171 val as u32
11172 }
11173 #[doc = "DHTMem RAM"]
11174 #[inline(always)]
11175 pub fn set_dhtmem_ram(&mut self, val: u32) {
11176 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11177 }
11178 }
11179 impl Default for HuffencAc059 {
11180 #[inline(always)]
11181 fn default() -> HuffencAc059 {
11182 HuffencAc059(0)
11183 }
11184 }
11185 impl core::fmt::Debug for HuffencAc059 {
11186 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11187 f.debug_struct("HuffencAc059")
11188 .field("dhtmem_ram", &self.dhtmem_ram())
11189 .finish()
11190 }
11191 }
11192 #[cfg(feature = "defmt")]
11193 impl defmt::Format for HuffencAc059 {
11194 fn format(&self, f: defmt::Formatter) {
11195 #[derive(defmt :: Format)]
11196 struct HuffencAc059 {
11197 dhtmem_ram: u32,
11198 }
11199 let proxy = HuffencAc059 {
11200 dhtmem_ram: self.dhtmem_ram(),
11201 };
11202 defmt::write!(f, "{}", proxy)
11203 }
11204 }
11205 #[doc = "JPEG encoder, AC Huffman table 0"]
11206 #[repr(transparent)]
11207 #[derive(Copy, Clone, Eq, PartialEq)]
11208 pub struct HuffencAc06(pub u32);
11209 impl HuffencAc06 {
11210 #[doc = "DHTMem RAM"]
11211 #[inline(always)]
11212 pub const fn dhtmem_ram(&self) -> u32 {
11213 let val = (self.0 >> 0usize) & 0xffff_ffff;
11214 val as u32
11215 }
11216 #[doc = "DHTMem RAM"]
11217 #[inline(always)]
11218 pub fn set_dhtmem_ram(&mut self, val: u32) {
11219 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11220 }
11221 }
11222 impl Default for HuffencAc06 {
11223 #[inline(always)]
11224 fn default() -> HuffencAc06 {
11225 HuffencAc06(0)
11226 }
11227 }
11228 impl core::fmt::Debug for HuffencAc06 {
11229 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11230 f.debug_struct("HuffencAc06")
11231 .field("dhtmem_ram", &self.dhtmem_ram())
11232 .finish()
11233 }
11234 }
11235 #[cfg(feature = "defmt")]
11236 impl defmt::Format for HuffencAc06 {
11237 fn format(&self, f: defmt::Formatter) {
11238 #[derive(defmt :: Format)]
11239 struct HuffencAc06 {
11240 dhtmem_ram: u32,
11241 }
11242 let proxy = HuffencAc06 {
11243 dhtmem_ram: self.dhtmem_ram(),
11244 };
11245 defmt::write!(f, "{}", proxy)
11246 }
11247 }
11248 #[doc = "JPEG encoder, AC Huffman table 0"]
11249 #[repr(transparent)]
11250 #[derive(Copy, Clone, Eq, PartialEq)]
11251 pub struct HuffencAc060(pub u32);
11252 impl HuffencAc060 {
11253 #[doc = "DHTMem RAM"]
11254 #[inline(always)]
11255 pub const fn dhtmem_ram(&self) -> u32 {
11256 let val = (self.0 >> 0usize) & 0xffff_ffff;
11257 val as u32
11258 }
11259 #[doc = "DHTMem RAM"]
11260 #[inline(always)]
11261 pub fn set_dhtmem_ram(&mut self, val: u32) {
11262 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11263 }
11264 }
11265 impl Default for HuffencAc060 {
11266 #[inline(always)]
11267 fn default() -> HuffencAc060 {
11268 HuffencAc060(0)
11269 }
11270 }
11271 impl core::fmt::Debug for HuffencAc060 {
11272 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11273 f.debug_struct("HuffencAc060")
11274 .field("dhtmem_ram", &self.dhtmem_ram())
11275 .finish()
11276 }
11277 }
11278 #[cfg(feature = "defmt")]
11279 impl defmt::Format for HuffencAc060 {
11280 fn format(&self, f: defmt::Formatter) {
11281 #[derive(defmt :: Format)]
11282 struct HuffencAc060 {
11283 dhtmem_ram: u32,
11284 }
11285 let proxy = HuffencAc060 {
11286 dhtmem_ram: self.dhtmem_ram(),
11287 };
11288 defmt::write!(f, "{}", proxy)
11289 }
11290 }
11291 #[doc = "JPEG encoder, AC Huffman table 0"]
11292 #[repr(transparent)]
11293 #[derive(Copy, Clone, Eq, PartialEq)]
11294 pub struct HuffencAc061(pub u32);
11295 impl HuffencAc061 {
11296 #[doc = "DHTMem RAM"]
11297 #[inline(always)]
11298 pub const fn dhtmem_ram(&self) -> u32 {
11299 let val = (self.0 >> 0usize) & 0xffff_ffff;
11300 val as u32
11301 }
11302 #[doc = "DHTMem RAM"]
11303 #[inline(always)]
11304 pub fn set_dhtmem_ram(&mut self, val: u32) {
11305 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11306 }
11307 }
11308 impl Default for HuffencAc061 {
11309 #[inline(always)]
11310 fn default() -> HuffencAc061 {
11311 HuffencAc061(0)
11312 }
11313 }
11314 impl core::fmt::Debug for HuffencAc061 {
11315 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11316 f.debug_struct("HuffencAc061")
11317 .field("dhtmem_ram", &self.dhtmem_ram())
11318 .finish()
11319 }
11320 }
11321 #[cfg(feature = "defmt")]
11322 impl defmt::Format for HuffencAc061 {
11323 fn format(&self, f: defmt::Formatter) {
11324 #[derive(defmt :: Format)]
11325 struct HuffencAc061 {
11326 dhtmem_ram: u32,
11327 }
11328 let proxy = HuffencAc061 {
11329 dhtmem_ram: self.dhtmem_ram(),
11330 };
11331 defmt::write!(f, "{}", proxy)
11332 }
11333 }
11334 #[doc = "JPEG encoder, AC Huffman table 0"]
11335 #[repr(transparent)]
11336 #[derive(Copy, Clone, Eq, PartialEq)]
11337 pub struct HuffencAc062(pub u32);
11338 impl HuffencAc062 {
11339 #[doc = "DHTMem RAM"]
11340 #[inline(always)]
11341 pub const fn dhtmem_ram(&self) -> u32 {
11342 let val = (self.0 >> 0usize) & 0xffff_ffff;
11343 val as u32
11344 }
11345 #[doc = "DHTMem RAM"]
11346 #[inline(always)]
11347 pub fn set_dhtmem_ram(&mut self, val: u32) {
11348 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11349 }
11350 }
11351 impl Default for HuffencAc062 {
11352 #[inline(always)]
11353 fn default() -> HuffencAc062 {
11354 HuffencAc062(0)
11355 }
11356 }
11357 impl core::fmt::Debug for HuffencAc062 {
11358 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11359 f.debug_struct("HuffencAc062")
11360 .field("dhtmem_ram", &self.dhtmem_ram())
11361 .finish()
11362 }
11363 }
11364 #[cfg(feature = "defmt")]
11365 impl defmt::Format for HuffencAc062 {
11366 fn format(&self, f: defmt::Formatter) {
11367 #[derive(defmt :: Format)]
11368 struct HuffencAc062 {
11369 dhtmem_ram: u32,
11370 }
11371 let proxy = HuffencAc062 {
11372 dhtmem_ram: self.dhtmem_ram(),
11373 };
11374 defmt::write!(f, "{}", proxy)
11375 }
11376 }
11377 #[doc = "JPEG encoder, AC Huffman table 0"]
11378 #[repr(transparent)]
11379 #[derive(Copy, Clone, Eq, PartialEq)]
11380 pub struct HuffencAc063(pub u32);
11381 impl HuffencAc063 {
11382 #[doc = "DHTMem RAM"]
11383 #[inline(always)]
11384 pub const fn dhtmem_ram(&self) -> u32 {
11385 let val = (self.0 >> 0usize) & 0xffff_ffff;
11386 val as u32
11387 }
11388 #[doc = "DHTMem RAM"]
11389 #[inline(always)]
11390 pub fn set_dhtmem_ram(&mut self, val: u32) {
11391 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11392 }
11393 }
11394 impl Default for HuffencAc063 {
11395 #[inline(always)]
11396 fn default() -> HuffencAc063 {
11397 HuffencAc063(0)
11398 }
11399 }
11400 impl core::fmt::Debug for HuffencAc063 {
11401 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11402 f.debug_struct("HuffencAc063")
11403 .field("dhtmem_ram", &self.dhtmem_ram())
11404 .finish()
11405 }
11406 }
11407 #[cfg(feature = "defmt")]
11408 impl defmt::Format for HuffencAc063 {
11409 fn format(&self, f: defmt::Formatter) {
11410 #[derive(defmt :: Format)]
11411 struct HuffencAc063 {
11412 dhtmem_ram: u32,
11413 }
11414 let proxy = HuffencAc063 {
11415 dhtmem_ram: self.dhtmem_ram(),
11416 };
11417 defmt::write!(f, "{}", proxy)
11418 }
11419 }
11420 #[doc = "JPEG encoder, AC Huffman table 0"]
11421 #[repr(transparent)]
11422 #[derive(Copy, Clone, Eq, PartialEq)]
11423 pub struct HuffencAc064(pub u32);
11424 impl HuffencAc064 {
11425 #[doc = "DHTMem RAM"]
11426 #[inline(always)]
11427 pub const fn dhtmem_ram(&self) -> u32 {
11428 let val = (self.0 >> 0usize) & 0xffff_ffff;
11429 val as u32
11430 }
11431 #[doc = "DHTMem RAM"]
11432 #[inline(always)]
11433 pub fn set_dhtmem_ram(&mut self, val: u32) {
11434 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11435 }
11436 }
11437 impl Default for HuffencAc064 {
11438 #[inline(always)]
11439 fn default() -> HuffencAc064 {
11440 HuffencAc064(0)
11441 }
11442 }
11443 impl core::fmt::Debug for HuffencAc064 {
11444 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11445 f.debug_struct("HuffencAc064")
11446 .field("dhtmem_ram", &self.dhtmem_ram())
11447 .finish()
11448 }
11449 }
11450 #[cfg(feature = "defmt")]
11451 impl defmt::Format for HuffencAc064 {
11452 fn format(&self, f: defmt::Formatter) {
11453 #[derive(defmt :: Format)]
11454 struct HuffencAc064 {
11455 dhtmem_ram: u32,
11456 }
11457 let proxy = HuffencAc064 {
11458 dhtmem_ram: self.dhtmem_ram(),
11459 };
11460 defmt::write!(f, "{}", proxy)
11461 }
11462 }
11463 #[doc = "JPEG encoder, AC Huffman table 0"]
11464 #[repr(transparent)]
11465 #[derive(Copy, Clone, Eq, PartialEq)]
11466 pub struct HuffencAc065(pub u32);
11467 impl HuffencAc065 {
11468 #[doc = "DHTMem RAM"]
11469 #[inline(always)]
11470 pub const fn dhtmem_ram(&self) -> u32 {
11471 let val = (self.0 >> 0usize) & 0xffff_ffff;
11472 val as u32
11473 }
11474 #[doc = "DHTMem RAM"]
11475 #[inline(always)]
11476 pub fn set_dhtmem_ram(&mut self, val: u32) {
11477 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11478 }
11479 }
11480 impl Default for HuffencAc065 {
11481 #[inline(always)]
11482 fn default() -> HuffencAc065 {
11483 HuffencAc065(0)
11484 }
11485 }
11486 impl core::fmt::Debug for HuffencAc065 {
11487 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11488 f.debug_struct("HuffencAc065")
11489 .field("dhtmem_ram", &self.dhtmem_ram())
11490 .finish()
11491 }
11492 }
11493 #[cfg(feature = "defmt")]
11494 impl defmt::Format for HuffencAc065 {
11495 fn format(&self, f: defmt::Formatter) {
11496 #[derive(defmt :: Format)]
11497 struct HuffencAc065 {
11498 dhtmem_ram: u32,
11499 }
11500 let proxy = HuffencAc065 {
11501 dhtmem_ram: self.dhtmem_ram(),
11502 };
11503 defmt::write!(f, "{}", proxy)
11504 }
11505 }
11506 #[doc = "JPEG encoder, AC Huffman table 0"]
11507 #[repr(transparent)]
11508 #[derive(Copy, Clone, Eq, PartialEq)]
11509 pub struct HuffencAc066(pub u32);
11510 impl HuffencAc066 {
11511 #[doc = "DHTMem RAM"]
11512 #[inline(always)]
11513 pub const fn dhtmem_ram(&self) -> u32 {
11514 let val = (self.0 >> 0usize) & 0xffff_ffff;
11515 val as u32
11516 }
11517 #[doc = "DHTMem RAM"]
11518 #[inline(always)]
11519 pub fn set_dhtmem_ram(&mut self, val: u32) {
11520 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11521 }
11522 }
11523 impl Default for HuffencAc066 {
11524 #[inline(always)]
11525 fn default() -> HuffencAc066 {
11526 HuffencAc066(0)
11527 }
11528 }
11529 impl core::fmt::Debug for HuffencAc066 {
11530 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11531 f.debug_struct("HuffencAc066")
11532 .field("dhtmem_ram", &self.dhtmem_ram())
11533 .finish()
11534 }
11535 }
11536 #[cfg(feature = "defmt")]
11537 impl defmt::Format for HuffencAc066 {
11538 fn format(&self, f: defmt::Formatter) {
11539 #[derive(defmt :: Format)]
11540 struct HuffencAc066 {
11541 dhtmem_ram: u32,
11542 }
11543 let proxy = HuffencAc066 {
11544 dhtmem_ram: self.dhtmem_ram(),
11545 };
11546 defmt::write!(f, "{}", proxy)
11547 }
11548 }
11549 #[doc = "JPEG encoder, AC Huffman table 0"]
11550 #[repr(transparent)]
11551 #[derive(Copy, Clone, Eq, PartialEq)]
11552 pub struct HuffencAc067(pub u32);
11553 impl HuffencAc067 {
11554 #[doc = "DHTMem RAM"]
11555 #[inline(always)]
11556 pub const fn dhtmem_ram(&self) -> u32 {
11557 let val = (self.0 >> 0usize) & 0xffff_ffff;
11558 val as u32
11559 }
11560 #[doc = "DHTMem RAM"]
11561 #[inline(always)]
11562 pub fn set_dhtmem_ram(&mut self, val: u32) {
11563 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11564 }
11565 }
11566 impl Default for HuffencAc067 {
11567 #[inline(always)]
11568 fn default() -> HuffencAc067 {
11569 HuffencAc067(0)
11570 }
11571 }
11572 impl core::fmt::Debug for HuffencAc067 {
11573 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11574 f.debug_struct("HuffencAc067")
11575 .field("dhtmem_ram", &self.dhtmem_ram())
11576 .finish()
11577 }
11578 }
11579 #[cfg(feature = "defmt")]
11580 impl defmt::Format for HuffencAc067 {
11581 fn format(&self, f: defmt::Formatter) {
11582 #[derive(defmt :: Format)]
11583 struct HuffencAc067 {
11584 dhtmem_ram: u32,
11585 }
11586 let proxy = HuffencAc067 {
11587 dhtmem_ram: self.dhtmem_ram(),
11588 };
11589 defmt::write!(f, "{}", proxy)
11590 }
11591 }
11592 #[doc = "JPEG encoder, AC Huffman table 0"]
11593 #[repr(transparent)]
11594 #[derive(Copy, Clone, Eq, PartialEq)]
11595 pub struct HuffencAc068(pub u32);
11596 impl HuffencAc068 {
11597 #[doc = "DHTMem RAM"]
11598 #[inline(always)]
11599 pub const fn dhtmem_ram(&self) -> u32 {
11600 let val = (self.0 >> 0usize) & 0xffff_ffff;
11601 val as u32
11602 }
11603 #[doc = "DHTMem RAM"]
11604 #[inline(always)]
11605 pub fn set_dhtmem_ram(&mut self, val: u32) {
11606 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11607 }
11608 }
11609 impl Default for HuffencAc068 {
11610 #[inline(always)]
11611 fn default() -> HuffencAc068 {
11612 HuffencAc068(0)
11613 }
11614 }
11615 impl core::fmt::Debug for HuffencAc068 {
11616 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11617 f.debug_struct("HuffencAc068")
11618 .field("dhtmem_ram", &self.dhtmem_ram())
11619 .finish()
11620 }
11621 }
11622 #[cfg(feature = "defmt")]
11623 impl defmt::Format for HuffencAc068 {
11624 fn format(&self, f: defmt::Formatter) {
11625 #[derive(defmt :: Format)]
11626 struct HuffencAc068 {
11627 dhtmem_ram: u32,
11628 }
11629 let proxy = HuffencAc068 {
11630 dhtmem_ram: self.dhtmem_ram(),
11631 };
11632 defmt::write!(f, "{}", proxy)
11633 }
11634 }
11635 #[doc = "JPEG encoder, AC Huffman table 0"]
11636 #[repr(transparent)]
11637 #[derive(Copy, Clone, Eq, PartialEq)]
11638 pub struct HuffencAc069(pub u32);
11639 impl HuffencAc069 {
11640 #[doc = "DHTMem RAM"]
11641 #[inline(always)]
11642 pub const fn dhtmem_ram(&self) -> u32 {
11643 let val = (self.0 >> 0usize) & 0xffff_ffff;
11644 val as u32
11645 }
11646 #[doc = "DHTMem RAM"]
11647 #[inline(always)]
11648 pub fn set_dhtmem_ram(&mut self, val: u32) {
11649 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11650 }
11651 }
11652 impl Default for HuffencAc069 {
11653 #[inline(always)]
11654 fn default() -> HuffencAc069 {
11655 HuffencAc069(0)
11656 }
11657 }
11658 impl core::fmt::Debug for HuffencAc069 {
11659 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11660 f.debug_struct("HuffencAc069")
11661 .field("dhtmem_ram", &self.dhtmem_ram())
11662 .finish()
11663 }
11664 }
11665 #[cfg(feature = "defmt")]
11666 impl defmt::Format for HuffencAc069 {
11667 fn format(&self, f: defmt::Formatter) {
11668 #[derive(defmt :: Format)]
11669 struct HuffencAc069 {
11670 dhtmem_ram: u32,
11671 }
11672 let proxy = HuffencAc069 {
11673 dhtmem_ram: self.dhtmem_ram(),
11674 };
11675 defmt::write!(f, "{}", proxy)
11676 }
11677 }
11678 #[doc = "JPEG encoder, AC Huffman table 0"]
11679 #[repr(transparent)]
11680 #[derive(Copy, Clone, Eq, PartialEq)]
11681 pub struct HuffencAc07(pub u32);
11682 impl HuffencAc07 {
11683 #[doc = "DHTMem RAM"]
11684 #[inline(always)]
11685 pub const fn dhtmem_ram(&self) -> u32 {
11686 let val = (self.0 >> 0usize) & 0xffff_ffff;
11687 val as u32
11688 }
11689 #[doc = "DHTMem RAM"]
11690 #[inline(always)]
11691 pub fn set_dhtmem_ram(&mut self, val: u32) {
11692 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11693 }
11694 }
11695 impl Default for HuffencAc07 {
11696 #[inline(always)]
11697 fn default() -> HuffencAc07 {
11698 HuffencAc07(0)
11699 }
11700 }
11701 impl core::fmt::Debug for HuffencAc07 {
11702 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11703 f.debug_struct("HuffencAc07")
11704 .field("dhtmem_ram", &self.dhtmem_ram())
11705 .finish()
11706 }
11707 }
11708 #[cfg(feature = "defmt")]
11709 impl defmt::Format for HuffencAc07 {
11710 fn format(&self, f: defmt::Formatter) {
11711 #[derive(defmt :: Format)]
11712 struct HuffencAc07 {
11713 dhtmem_ram: u32,
11714 }
11715 let proxy = HuffencAc07 {
11716 dhtmem_ram: self.dhtmem_ram(),
11717 };
11718 defmt::write!(f, "{}", proxy)
11719 }
11720 }
11721 #[doc = "JPEG encoder, AC Huffman table 0"]
11722 #[repr(transparent)]
11723 #[derive(Copy, Clone, Eq, PartialEq)]
11724 pub struct HuffencAc070(pub u32);
11725 impl HuffencAc070 {
11726 #[doc = "DHTMem RAM"]
11727 #[inline(always)]
11728 pub const fn dhtmem_ram(&self) -> u32 {
11729 let val = (self.0 >> 0usize) & 0xffff_ffff;
11730 val as u32
11731 }
11732 #[doc = "DHTMem RAM"]
11733 #[inline(always)]
11734 pub fn set_dhtmem_ram(&mut self, val: u32) {
11735 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11736 }
11737 }
11738 impl Default for HuffencAc070 {
11739 #[inline(always)]
11740 fn default() -> HuffencAc070 {
11741 HuffencAc070(0)
11742 }
11743 }
11744 impl core::fmt::Debug for HuffencAc070 {
11745 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11746 f.debug_struct("HuffencAc070")
11747 .field("dhtmem_ram", &self.dhtmem_ram())
11748 .finish()
11749 }
11750 }
11751 #[cfg(feature = "defmt")]
11752 impl defmt::Format for HuffencAc070 {
11753 fn format(&self, f: defmt::Formatter) {
11754 #[derive(defmt :: Format)]
11755 struct HuffencAc070 {
11756 dhtmem_ram: u32,
11757 }
11758 let proxy = HuffencAc070 {
11759 dhtmem_ram: self.dhtmem_ram(),
11760 };
11761 defmt::write!(f, "{}", proxy)
11762 }
11763 }
11764 #[doc = "JPEG encoder, AC Huffman table 0"]
11765 #[repr(transparent)]
11766 #[derive(Copy, Clone, Eq, PartialEq)]
11767 pub struct HuffencAc071(pub u32);
11768 impl HuffencAc071 {
11769 #[doc = "DHTMem RAM"]
11770 #[inline(always)]
11771 pub const fn dhtmem_ram(&self) -> u32 {
11772 let val = (self.0 >> 0usize) & 0xffff_ffff;
11773 val as u32
11774 }
11775 #[doc = "DHTMem RAM"]
11776 #[inline(always)]
11777 pub fn set_dhtmem_ram(&mut self, val: u32) {
11778 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11779 }
11780 }
11781 impl Default for HuffencAc071 {
11782 #[inline(always)]
11783 fn default() -> HuffencAc071 {
11784 HuffencAc071(0)
11785 }
11786 }
11787 impl core::fmt::Debug for HuffencAc071 {
11788 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11789 f.debug_struct("HuffencAc071")
11790 .field("dhtmem_ram", &self.dhtmem_ram())
11791 .finish()
11792 }
11793 }
11794 #[cfg(feature = "defmt")]
11795 impl defmt::Format for HuffencAc071 {
11796 fn format(&self, f: defmt::Formatter) {
11797 #[derive(defmt :: Format)]
11798 struct HuffencAc071 {
11799 dhtmem_ram: u32,
11800 }
11801 let proxy = HuffencAc071 {
11802 dhtmem_ram: self.dhtmem_ram(),
11803 };
11804 defmt::write!(f, "{}", proxy)
11805 }
11806 }
11807 #[doc = "JPEG encoder, AC Huffman table 0"]
11808 #[repr(transparent)]
11809 #[derive(Copy, Clone, Eq, PartialEq)]
11810 pub struct HuffencAc072(pub u32);
11811 impl HuffencAc072 {
11812 #[doc = "DHTMem RAM"]
11813 #[inline(always)]
11814 pub const fn dhtmem_ram(&self) -> u32 {
11815 let val = (self.0 >> 0usize) & 0xffff_ffff;
11816 val as u32
11817 }
11818 #[doc = "DHTMem RAM"]
11819 #[inline(always)]
11820 pub fn set_dhtmem_ram(&mut self, val: u32) {
11821 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11822 }
11823 }
11824 impl Default for HuffencAc072 {
11825 #[inline(always)]
11826 fn default() -> HuffencAc072 {
11827 HuffencAc072(0)
11828 }
11829 }
11830 impl core::fmt::Debug for HuffencAc072 {
11831 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11832 f.debug_struct("HuffencAc072")
11833 .field("dhtmem_ram", &self.dhtmem_ram())
11834 .finish()
11835 }
11836 }
11837 #[cfg(feature = "defmt")]
11838 impl defmt::Format for HuffencAc072 {
11839 fn format(&self, f: defmt::Formatter) {
11840 #[derive(defmt :: Format)]
11841 struct HuffencAc072 {
11842 dhtmem_ram: u32,
11843 }
11844 let proxy = HuffencAc072 {
11845 dhtmem_ram: self.dhtmem_ram(),
11846 };
11847 defmt::write!(f, "{}", proxy)
11848 }
11849 }
11850 #[doc = "JPEG encoder, AC Huffman table 0"]
11851 #[repr(transparent)]
11852 #[derive(Copy, Clone, Eq, PartialEq)]
11853 pub struct HuffencAc073(pub u32);
11854 impl HuffencAc073 {
11855 #[doc = "DHTMem RAM"]
11856 #[inline(always)]
11857 pub const fn dhtmem_ram(&self) -> u32 {
11858 let val = (self.0 >> 0usize) & 0xffff_ffff;
11859 val as u32
11860 }
11861 #[doc = "DHTMem RAM"]
11862 #[inline(always)]
11863 pub fn set_dhtmem_ram(&mut self, val: u32) {
11864 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11865 }
11866 }
11867 impl Default for HuffencAc073 {
11868 #[inline(always)]
11869 fn default() -> HuffencAc073 {
11870 HuffencAc073(0)
11871 }
11872 }
11873 impl core::fmt::Debug for HuffencAc073 {
11874 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11875 f.debug_struct("HuffencAc073")
11876 .field("dhtmem_ram", &self.dhtmem_ram())
11877 .finish()
11878 }
11879 }
11880 #[cfg(feature = "defmt")]
11881 impl defmt::Format for HuffencAc073 {
11882 fn format(&self, f: defmt::Formatter) {
11883 #[derive(defmt :: Format)]
11884 struct HuffencAc073 {
11885 dhtmem_ram: u32,
11886 }
11887 let proxy = HuffencAc073 {
11888 dhtmem_ram: self.dhtmem_ram(),
11889 };
11890 defmt::write!(f, "{}", proxy)
11891 }
11892 }
11893 #[doc = "JPEG encoder, AC Huffman table 0"]
11894 #[repr(transparent)]
11895 #[derive(Copy, Clone, Eq, PartialEq)]
11896 pub struct HuffencAc074(pub u32);
11897 impl HuffencAc074 {
11898 #[doc = "DHTMem RAM"]
11899 #[inline(always)]
11900 pub const fn dhtmem_ram(&self) -> u32 {
11901 let val = (self.0 >> 0usize) & 0xffff_ffff;
11902 val as u32
11903 }
11904 #[doc = "DHTMem RAM"]
11905 #[inline(always)]
11906 pub fn set_dhtmem_ram(&mut self, val: u32) {
11907 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11908 }
11909 }
11910 impl Default for HuffencAc074 {
11911 #[inline(always)]
11912 fn default() -> HuffencAc074 {
11913 HuffencAc074(0)
11914 }
11915 }
11916 impl core::fmt::Debug for HuffencAc074 {
11917 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11918 f.debug_struct("HuffencAc074")
11919 .field("dhtmem_ram", &self.dhtmem_ram())
11920 .finish()
11921 }
11922 }
11923 #[cfg(feature = "defmt")]
11924 impl defmt::Format for HuffencAc074 {
11925 fn format(&self, f: defmt::Formatter) {
11926 #[derive(defmt :: Format)]
11927 struct HuffencAc074 {
11928 dhtmem_ram: u32,
11929 }
11930 let proxy = HuffencAc074 {
11931 dhtmem_ram: self.dhtmem_ram(),
11932 };
11933 defmt::write!(f, "{}", proxy)
11934 }
11935 }
11936 #[doc = "JPEG encoder, AC Huffman table 0"]
11937 #[repr(transparent)]
11938 #[derive(Copy, Clone, Eq, PartialEq)]
11939 pub struct HuffencAc075(pub u32);
11940 impl HuffencAc075 {
11941 #[doc = "DHTMem RAM"]
11942 #[inline(always)]
11943 pub const fn dhtmem_ram(&self) -> u32 {
11944 let val = (self.0 >> 0usize) & 0xffff_ffff;
11945 val as u32
11946 }
11947 #[doc = "DHTMem RAM"]
11948 #[inline(always)]
11949 pub fn set_dhtmem_ram(&mut self, val: u32) {
11950 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11951 }
11952 }
11953 impl Default for HuffencAc075 {
11954 #[inline(always)]
11955 fn default() -> HuffencAc075 {
11956 HuffencAc075(0)
11957 }
11958 }
11959 impl core::fmt::Debug for HuffencAc075 {
11960 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
11961 f.debug_struct("HuffencAc075")
11962 .field("dhtmem_ram", &self.dhtmem_ram())
11963 .finish()
11964 }
11965 }
11966 #[cfg(feature = "defmt")]
11967 impl defmt::Format for HuffencAc075 {
11968 fn format(&self, f: defmt::Formatter) {
11969 #[derive(defmt :: Format)]
11970 struct HuffencAc075 {
11971 dhtmem_ram: u32,
11972 }
11973 let proxy = HuffencAc075 {
11974 dhtmem_ram: self.dhtmem_ram(),
11975 };
11976 defmt::write!(f, "{}", proxy)
11977 }
11978 }
11979 #[doc = "JPEG encoder, AC Huffman table 0"]
11980 #[repr(transparent)]
11981 #[derive(Copy, Clone, Eq, PartialEq)]
11982 pub struct HuffencAc076(pub u32);
11983 impl HuffencAc076 {
11984 #[doc = "DHTMem RAM"]
11985 #[inline(always)]
11986 pub const fn dhtmem_ram(&self) -> u32 {
11987 let val = (self.0 >> 0usize) & 0xffff_ffff;
11988 val as u32
11989 }
11990 #[doc = "DHTMem RAM"]
11991 #[inline(always)]
11992 pub fn set_dhtmem_ram(&mut self, val: u32) {
11993 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
11994 }
11995 }
11996 impl Default for HuffencAc076 {
11997 #[inline(always)]
11998 fn default() -> HuffencAc076 {
11999 HuffencAc076(0)
12000 }
12001 }
12002 impl core::fmt::Debug for HuffencAc076 {
12003 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12004 f.debug_struct("HuffencAc076")
12005 .field("dhtmem_ram", &self.dhtmem_ram())
12006 .finish()
12007 }
12008 }
12009 #[cfg(feature = "defmt")]
12010 impl defmt::Format for HuffencAc076 {
12011 fn format(&self, f: defmt::Formatter) {
12012 #[derive(defmt :: Format)]
12013 struct HuffencAc076 {
12014 dhtmem_ram: u32,
12015 }
12016 let proxy = HuffencAc076 {
12017 dhtmem_ram: self.dhtmem_ram(),
12018 };
12019 defmt::write!(f, "{}", proxy)
12020 }
12021 }
12022 #[doc = "JPEG encoder, AC Huffman table 0"]
12023 #[repr(transparent)]
12024 #[derive(Copy, Clone, Eq, PartialEq)]
12025 pub struct HuffencAc077(pub u32);
12026 impl HuffencAc077 {
12027 #[doc = "DHTMem RAM"]
12028 #[inline(always)]
12029 pub const fn dhtmem_ram(&self) -> u32 {
12030 let val = (self.0 >> 0usize) & 0xffff_ffff;
12031 val as u32
12032 }
12033 #[doc = "DHTMem RAM"]
12034 #[inline(always)]
12035 pub fn set_dhtmem_ram(&mut self, val: u32) {
12036 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12037 }
12038 }
12039 impl Default for HuffencAc077 {
12040 #[inline(always)]
12041 fn default() -> HuffencAc077 {
12042 HuffencAc077(0)
12043 }
12044 }
12045 impl core::fmt::Debug for HuffencAc077 {
12046 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12047 f.debug_struct("HuffencAc077")
12048 .field("dhtmem_ram", &self.dhtmem_ram())
12049 .finish()
12050 }
12051 }
12052 #[cfg(feature = "defmt")]
12053 impl defmt::Format for HuffencAc077 {
12054 fn format(&self, f: defmt::Formatter) {
12055 #[derive(defmt :: Format)]
12056 struct HuffencAc077 {
12057 dhtmem_ram: u32,
12058 }
12059 let proxy = HuffencAc077 {
12060 dhtmem_ram: self.dhtmem_ram(),
12061 };
12062 defmt::write!(f, "{}", proxy)
12063 }
12064 }
12065 #[doc = "JPEG encoder, AC Huffman table 0"]
12066 #[repr(transparent)]
12067 #[derive(Copy, Clone, Eq, PartialEq)]
12068 pub struct HuffencAc078(pub u32);
12069 impl HuffencAc078 {
12070 #[doc = "DHTMem RAM"]
12071 #[inline(always)]
12072 pub const fn dhtmem_ram(&self) -> u32 {
12073 let val = (self.0 >> 0usize) & 0xffff_ffff;
12074 val as u32
12075 }
12076 #[doc = "DHTMem RAM"]
12077 #[inline(always)]
12078 pub fn set_dhtmem_ram(&mut self, val: u32) {
12079 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12080 }
12081 }
12082 impl Default for HuffencAc078 {
12083 #[inline(always)]
12084 fn default() -> HuffencAc078 {
12085 HuffencAc078(0)
12086 }
12087 }
12088 impl core::fmt::Debug for HuffencAc078 {
12089 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12090 f.debug_struct("HuffencAc078")
12091 .field("dhtmem_ram", &self.dhtmem_ram())
12092 .finish()
12093 }
12094 }
12095 #[cfg(feature = "defmt")]
12096 impl defmt::Format for HuffencAc078 {
12097 fn format(&self, f: defmt::Formatter) {
12098 #[derive(defmt :: Format)]
12099 struct HuffencAc078 {
12100 dhtmem_ram: u32,
12101 }
12102 let proxy = HuffencAc078 {
12103 dhtmem_ram: self.dhtmem_ram(),
12104 };
12105 defmt::write!(f, "{}", proxy)
12106 }
12107 }
12108 #[doc = "JPEG encoder, AC Huffman table 0"]
12109 #[repr(transparent)]
12110 #[derive(Copy, Clone, Eq, PartialEq)]
12111 pub struct HuffencAc079(pub u32);
12112 impl HuffencAc079 {
12113 #[doc = "DHTMem RAM"]
12114 #[inline(always)]
12115 pub const fn dhtmem_ram(&self) -> u32 {
12116 let val = (self.0 >> 0usize) & 0xffff_ffff;
12117 val as u32
12118 }
12119 #[doc = "DHTMem RAM"]
12120 #[inline(always)]
12121 pub fn set_dhtmem_ram(&mut self, val: u32) {
12122 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12123 }
12124 }
12125 impl Default for HuffencAc079 {
12126 #[inline(always)]
12127 fn default() -> HuffencAc079 {
12128 HuffencAc079(0)
12129 }
12130 }
12131 impl core::fmt::Debug for HuffencAc079 {
12132 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12133 f.debug_struct("HuffencAc079")
12134 .field("dhtmem_ram", &self.dhtmem_ram())
12135 .finish()
12136 }
12137 }
12138 #[cfg(feature = "defmt")]
12139 impl defmt::Format for HuffencAc079 {
12140 fn format(&self, f: defmt::Formatter) {
12141 #[derive(defmt :: Format)]
12142 struct HuffencAc079 {
12143 dhtmem_ram: u32,
12144 }
12145 let proxy = HuffencAc079 {
12146 dhtmem_ram: self.dhtmem_ram(),
12147 };
12148 defmt::write!(f, "{}", proxy)
12149 }
12150 }
12151 #[doc = "JPEG encoder, AC Huffman table 0"]
12152 #[repr(transparent)]
12153 #[derive(Copy, Clone, Eq, PartialEq)]
12154 pub struct HuffencAc08(pub u32);
12155 impl HuffencAc08 {
12156 #[doc = "DHTMem RAM"]
12157 #[inline(always)]
12158 pub const fn dhtmem_ram(&self) -> u32 {
12159 let val = (self.0 >> 0usize) & 0xffff_ffff;
12160 val as u32
12161 }
12162 #[doc = "DHTMem RAM"]
12163 #[inline(always)]
12164 pub fn set_dhtmem_ram(&mut self, val: u32) {
12165 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12166 }
12167 }
12168 impl Default for HuffencAc08 {
12169 #[inline(always)]
12170 fn default() -> HuffencAc08 {
12171 HuffencAc08(0)
12172 }
12173 }
12174 impl core::fmt::Debug for HuffencAc08 {
12175 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12176 f.debug_struct("HuffencAc08")
12177 .field("dhtmem_ram", &self.dhtmem_ram())
12178 .finish()
12179 }
12180 }
12181 #[cfg(feature = "defmt")]
12182 impl defmt::Format for HuffencAc08 {
12183 fn format(&self, f: defmt::Formatter) {
12184 #[derive(defmt :: Format)]
12185 struct HuffencAc08 {
12186 dhtmem_ram: u32,
12187 }
12188 let proxy = HuffencAc08 {
12189 dhtmem_ram: self.dhtmem_ram(),
12190 };
12191 defmt::write!(f, "{}", proxy)
12192 }
12193 }
12194 #[doc = "JPEG encoder, AC Huffman table 0"]
12195 #[repr(transparent)]
12196 #[derive(Copy, Clone, Eq, PartialEq)]
12197 pub struct HuffencAc080(pub u32);
12198 impl HuffencAc080 {
12199 #[doc = "DHTMem RAM"]
12200 #[inline(always)]
12201 pub const fn dhtmem_ram(&self) -> u32 {
12202 let val = (self.0 >> 0usize) & 0xffff_ffff;
12203 val as u32
12204 }
12205 #[doc = "DHTMem RAM"]
12206 #[inline(always)]
12207 pub fn set_dhtmem_ram(&mut self, val: u32) {
12208 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12209 }
12210 }
12211 impl Default for HuffencAc080 {
12212 #[inline(always)]
12213 fn default() -> HuffencAc080 {
12214 HuffencAc080(0)
12215 }
12216 }
12217 impl core::fmt::Debug for HuffencAc080 {
12218 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12219 f.debug_struct("HuffencAc080")
12220 .field("dhtmem_ram", &self.dhtmem_ram())
12221 .finish()
12222 }
12223 }
12224 #[cfg(feature = "defmt")]
12225 impl defmt::Format for HuffencAc080 {
12226 fn format(&self, f: defmt::Formatter) {
12227 #[derive(defmt :: Format)]
12228 struct HuffencAc080 {
12229 dhtmem_ram: u32,
12230 }
12231 let proxy = HuffencAc080 {
12232 dhtmem_ram: self.dhtmem_ram(),
12233 };
12234 defmt::write!(f, "{}", proxy)
12235 }
12236 }
12237 #[doc = "JPEG encoder, AC Huffman table 0"]
12238 #[repr(transparent)]
12239 #[derive(Copy, Clone, Eq, PartialEq)]
12240 pub struct HuffencAc081(pub u32);
12241 impl HuffencAc081 {
12242 #[doc = "DHTMem RAM"]
12243 #[inline(always)]
12244 pub const fn dhtmem_ram(&self) -> u32 {
12245 let val = (self.0 >> 0usize) & 0xffff_ffff;
12246 val as u32
12247 }
12248 #[doc = "DHTMem RAM"]
12249 #[inline(always)]
12250 pub fn set_dhtmem_ram(&mut self, val: u32) {
12251 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12252 }
12253 }
12254 impl Default for HuffencAc081 {
12255 #[inline(always)]
12256 fn default() -> HuffencAc081 {
12257 HuffencAc081(0)
12258 }
12259 }
12260 impl core::fmt::Debug for HuffencAc081 {
12261 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12262 f.debug_struct("HuffencAc081")
12263 .field("dhtmem_ram", &self.dhtmem_ram())
12264 .finish()
12265 }
12266 }
12267 #[cfg(feature = "defmt")]
12268 impl defmt::Format for HuffencAc081 {
12269 fn format(&self, f: defmt::Formatter) {
12270 #[derive(defmt :: Format)]
12271 struct HuffencAc081 {
12272 dhtmem_ram: u32,
12273 }
12274 let proxy = HuffencAc081 {
12275 dhtmem_ram: self.dhtmem_ram(),
12276 };
12277 defmt::write!(f, "{}", proxy)
12278 }
12279 }
12280 #[doc = "JPEG encoder, AC Huffman table 0"]
12281 #[repr(transparent)]
12282 #[derive(Copy, Clone, Eq, PartialEq)]
12283 pub struct HuffencAc082(pub u32);
12284 impl HuffencAc082 {
12285 #[doc = "DHTMem RAM"]
12286 #[inline(always)]
12287 pub const fn dhtmem_ram(&self) -> u32 {
12288 let val = (self.0 >> 0usize) & 0xffff_ffff;
12289 val as u32
12290 }
12291 #[doc = "DHTMem RAM"]
12292 #[inline(always)]
12293 pub fn set_dhtmem_ram(&mut self, val: u32) {
12294 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12295 }
12296 }
12297 impl Default for HuffencAc082 {
12298 #[inline(always)]
12299 fn default() -> HuffencAc082 {
12300 HuffencAc082(0)
12301 }
12302 }
12303 impl core::fmt::Debug for HuffencAc082 {
12304 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12305 f.debug_struct("HuffencAc082")
12306 .field("dhtmem_ram", &self.dhtmem_ram())
12307 .finish()
12308 }
12309 }
12310 #[cfg(feature = "defmt")]
12311 impl defmt::Format for HuffencAc082 {
12312 fn format(&self, f: defmt::Formatter) {
12313 #[derive(defmt :: Format)]
12314 struct HuffencAc082 {
12315 dhtmem_ram: u32,
12316 }
12317 let proxy = HuffencAc082 {
12318 dhtmem_ram: self.dhtmem_ram(),
12319 };
12320 defmt::write!(f, "{}", proxy)
12321 }
12322 }
12323 #[doc = "JPEG encoder, AC Huffman table 0"]
12324 #[repr(transparent)]
12325 #[derive(Copy, Clone, Eq, PartialEq)]
12326 pub struct HuffencAc083(pub u32);
12327 impl HuffencAc083 {
12328 #[doc = "DHTMem RAM"]
12329 #[inline(always)]
12330 pub const fn dhtmem_ram(&self) -> u32 {
12331 let val = (self.0 >> 0usize) & 0xffff_ffff;
12332 val as u32
12333 }
12334 #[doc = "DHTMem RAM"]
12335 #[inline(always)]
12336 pub fn set_dhtmem_ram(&mut self, val: u32) {
12337 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12338 }
12339 }
12340 impl Default for HuffencAc083 {
12341 #[inline(always)]
12342 fn default() -> HuffencAc083 {
12343 HuffencAc083(0)
12344 }
12345 }
12346 impl core::fmt::Debug for HuffencAc083 {
12347 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12348 f.debug_struct("HuffencAc083")
12349 .field("dhtmem_ram", &self.dhtmem_ram())
12350 .finish()
12351 }
12352 }
12353 #[cfg(feature = "defmt")]
12354 impl defmt::Format for HuffencAc083 {
12355 fn format(&self, f: defmt::Formatter) {
12356 #[derive(defmt :: Format)]
12357 struct HuffencAc083 {
12358 dhtmem_ram: u32,
12359 }
12360 let proxy = HuffencAc083 {
12361 dhtmem_ram: self.dhtmem_ram(),
12362 };
12363 defmt::write!(f, "{}", proxy)
12364 }
12365 }
12366 #[doc = "JPEG encoder, AC Huffman table 0"]
12367 #[repr(transparent)]
12368 #[derive(Copy, Clone, Eq, PartialEq)]
12369 pub struct HuffencAc084(pub u32);
12370 impl HuffencAc084 {
12371 #[doc = "DHTMem RAM"]
12372 #[inline(always)]
12373 pub const fn dhtmem_ram(&self) -> u32 {
12374 let val = (self.0 >> 0usize) & 0xffff_ffff;
12375 val as u32
12376 }
12377 #[doc = "DHTMem RAM"]
12378 #[inline(always)]
12379 pub fn set_dhtmem_ram(&mut self, val: u32) {
12380 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12381 }
12382 }
12383 impl Default for HuffencAc084 {
12384 #[inline(always)]
12385 fn default() -> HuffencAc084 {
12386 HuffencAc084(0)
12387 }
12388 }
12389 impl core::fmt::Debug for HuffencAc084 {
12390 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12391 f.debug_struct("HuffencAc084")
12392 .field("dhtmem_ram", &self.dhtmem_ram())
12393 .finish()
12394 }
12395 }
12396 #[cfg(feature = "defmt")]
12397 impl defmt::Format for HuffencAc084 {
12398 fn format(&self, f: defmt::Formatter) {
12399 #[derive(defmt :: Format)]
12400 struct HuffencAc084 {
12401 dhtmem_ram: u32,
12402 }
12403 let proxy = HuffencAc084 {
12404 dhtmem_ram: self.dhtmem_ram(),
12405 };
12406 defmt::write!(f, "{}", proxy)
12407 }
12408 }
12409 #[doc = "JPEG encoder, AC Huffman table 0"]
12410 #[repr(transparent)]
12411 #[derive(Copy, Clone, Eq, PartialEq)]
12412 pub struct HuffencAc085(pub u32);
12413 impl HuffencAc085 {
12414 #[doc = "DHTMem RAM"]
12415 #[inline(always)]
12416 pub const fn dhtmem_ram(&self) -> u32 {
12417 let val = (self.0 >> 0usize) & 0xffff_ffff;
12418 val as u32
12419 }
12420 #[doc = "DHTMem RAM"]
12421 #[inline(always)]
12422 pub fn set_dhtmem_ram(&mut self, val: u32) {
12423 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12424 }
12425 }
12426 impl Default for HuffencAc085 {
12427 #[inline(always)]
12428 fn default() -> HuffencAc085 {
12429 HuffencAc085(0)
12430 }
12431 }
12432 impl core::fmt::Debug for HuffencAc085 {
12433 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12434 f.debug_struct("HuffencAc085")
12435 .field("dhtmem_ram", &self.dhtmem_ram())
12436 .finish()
12437 }
12438 }
12439 #[cfg(feature = "defmt")]
12440 impl defmt::Format for HuffencAc085 {
12441 fn format(&self, f: defmt::Formatter) {
12442 #[derive(defmt :: Format)]
12443 struct HuffencAc085 {
12444 dhtmem_ram: u32,
12445 }
12446 let proxy = HuffencAc085 {
12447 dhtmem_ram: self.dhtmem_ram(),
12448 };
12449 defmt::write!(f, "{}", proxy)
12450 }
12451 }
12452 #[doc = "JPEG encoder, AC Huffman table 0"]
12453 #[repr(transparent)]
12454 #[derive(Copy, Clone, Eq, PartialEq)]
12455 pub struct HuffencAc086(pub u32);
12456 impl HuffencAc086 {
12457 #[doc = "DHTMem RAM"]
12458 #[inline(always)]
12459 pub const fn dhtmem_ram(&self) -> u32 {
12460 let val = (self.0 >> 0usize) & 0xffff_ffff;
12461 val as u32
12462 }
12463 #[doc = "DHTMem RAM"]
12464 #[inline(always)]
12465 pub fn set_dhtmem_ram(&mut self, val: u32) {
12466 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12467 }
12468 }
12469 impl Default for HuffencAc086 {
12470 #[inline(always)]
12471 fn default() -> HuffencAc086 {
12472 HuffencAc086(0)
12473 }
12474 }
12475 impl core::fmt::Debug for HuffencAc086 {
12476 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12477 f.debug_struct("HuffencAc086")
12478 .field("dhtmem_ram", &self.dhtmem_ram())
12479 .finish()
12480 }
12481 }
12482 #[cfg(feature = "defmt")]
12483 impl defmt::Format for HuffencAc086 {
12484 fn format(&self, f: defmt::Formatter) {
12485 #[derive(defmt :: Format)]
12486 struct HuffencAc086 {
12487 dhtmem_ram: u32,
12488 }
12489 let proxy = HuffencAc086 {
12490 dhtmem_ram: self.dhtmem_ram(),
12491 };
12492 defmt::write!(f, "{}", proxy)
12493 }
12494 }
12495 #[doc = "JPEG encoder, AC Huffman table 0"]
12496 #[repr(transparent)]
12497 #[derive(Copy, Clone, Eq, PartialEq)]
12498 pub struct HuffencAc087(pub u32);
12499 impl HuffencAc087 {
12500 #[doc = "DHTMem RAM"]
12501 #[inline(always)]
12502 pub const fn dhtmem_ram(&self) -> u32 {
12503 let val = (self.0 >> 0usize) & 0xffff_ffff;
12504 val as u32
12505 }
12506 #[doc = "DHTMem RAM"]
12507 #[inline(always)]
12508 pub fn set_dhtmem_ram(&mut self, val: u32) {
12509 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12510 }
12511 }
12512 impl Default for HuffencAc087 {
12513 #[inline(always)]
12514 fn default() -> HuffencAc087 {
12515 HuffencAc087(0)
12516 }
12517 }
12518 impl core::fmt::Debug for HuffencAc087 {
12519 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12520 f.debug_struct("HuffencAc087")
12521 .field("dhtmem_ram", &self.dhtmem_ram())
12522 .finish()
12523 }
12524 }
12525 #[cfg(feature = "defmt")]
12526 impl defmt::Format for HuffencAc087 {
12527 fn format(&self, f: defmt::Formatter) {
12528 #[derive(defmt :: Format)]
12529 struct HuffencAc087 {
12530 dhtmem_ram: u32,
12531 }
12532 let proxy = HuffencAc087 {
12533 dhtmem_ram: self.dhtmem_ram(),
12534 };
12535 defmt::write!(f, "{}", proxy)
12536 }
12537 }
12538 #[doc = "JPEG encoder, AC Huffman table 0"]
12539 #[repr(transparent)]
12540 #[derive(Copy, Clone, Eq, PartialEq)]
12541 pub struct HuffencAc09(pub u32);
12542 impl HuffencAc09 {
12543 #[doc = "DHTMem RAM"]
12544 #[inline(always)]
12545 pub const fn dhtmem_ram(&self) -> u32 {
12546 let val = (self.0 >> 0usize) & 0xffff_ffff;
12547 val as u32
12548 }
12549 #[doc = "DHTMem RAM"]
12550 #[inline(always)]
12551 pub fn set_dhtmem_ram(&mut self, val: u32) {
12552 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12553 }
12554 }
12555 impl Default for HuffencAc09 {
12556 #[inline(always)]
12557 fn default() -> HuffencAc09 {
12558 HuffencAc09(0)
12559 }
12560 }
12561 impl core::fmt::Debug for HuffencAc09 {
12562 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12563 f.debug_struct("HuffencAc09")
12564 .field("dhtmem_ram", &self.dhtmem_ram())
12565 .finish()
12566 }
12567 }
12568 #[cfg(feature = "defmt")]
12569 impl defmt::Format for HuffencAc09 {
12570 fn format(&self, f: defmt::Formatter) {
12571 #[derive(defmt :: Format)]
12572 struct HuffencAc09 {
12573 dhtmem_ram: u32,
12574 }
12575 let proxy = HuffencAc09 {
12576 dhtmem_ram: self.dhtmem_ram(),
12577 };
12578 defmt::write!(f, "{}", proxy)
12579 }
12580 }
12581 #[doc = "JPEG encoder, AC Huffman table 1"]
12582 #[repr(transparent)]
12583 #[derive(Copy, Clone, Eq, PartialEq)]
12584 pub struct HuffencAc10(pub u32);
12585 impl HuffencAc10 {
12586 #[doc = "DHTMem RAM"]
12587 #[inline(always)]
12588 pub const fn dhtmem_ram(&self) -> u32 {
12589 let val = (self.0 >> 0usize) & 0xffff_ffff;
12590 val as u32
12591 }
12592 #[doc = "DHTMem RAM"]
12593 #[inline(always)]
12594 pub fn set_dhtmem_ram(&mut self, val: u32) {
12595 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12596 }
12597 }
12598 impl Default for HuffencAc10 {
12599 #[inline(always)]
12600 fn default() -> HuffencAc10 {
12601 HuffencAc10(0)
12602 }
12603 }
12604 impl core::fmt::Debug for HuffencAc10 {
12605 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12606 f.debug_struct("HuffencAc10")
12607 .field("dhtmem_ram", &self.dhtmem_ram())
12608 .finish()
12609 }
12610 }
12611 #[cfg(feature = "defmt")]
12612 impl defmt::Format for HuffencAc10 {
12613 fn format(&self, f: defmt::Formatter) {
12614 #[derive(defmt :: Format)]
12615 struct HuffencAc10 {
12616 dhtmem_ram: u32,
12617 }
12618 let proxy = HuffencAc10 {
12619 dhtmem_ram: self.dhtmem_ram(),
12620 };
12621 defmt::write!(f, "{}", proxy)
12622 }
12623 }
12624 #[doc = "JPEG encoder, AC Huffman table 1"]
12625 #[repr(transparent)]
12626 #[derive(Copy, Clone, Eq, PartialEq)]
12627 pub struct HuffencAc11(pub u32);
12628 impl HuffencAc11 {
12629 #[doc = "DHTMem RAM"]
12630 #[inline(always)]
12631 pub const fn dhtmem_ram(&self) -> u32 {
12632 let val = (self.0 >> 0usize) & 0xffff_ffff;
12633 val as u32
12634 }
12635 #[doc = "DHTMem RAM"]
12636 #[inline(always)]
12637 pub fn set_dhtmem_ram(&mut self, val: u32) {
12638 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12639 }
12640 }
12641 impl Default for HuffencAc11 {
12642 #[inline(always)]
12643 fn default() -> HuffencAc11 {
12644 HuffencAc11(0)
12645 }
12646 }
12647 impl core::fmt::Debug for HuffencAc11 {
12648 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12649 f.debug_struct("HuffencAc11")
12650 .field("dhtmem_ram", &self.dhtmem_ram())
12651 .finish()
12652 }
12653 }
12654 #[cfg(feature = "defmt")]
12655 impl defmt::Format for HuffencAc11 {
12656 fn format(&self, f: defmt::Formatter) {
12657 #[derive(defmt :: Format)]
12658 struct HuffencAc11 {
12659 dhtmem_ram: u32,
12660 }
12661 let proxy = HuffencAc11 {
12662 dhtmem_ram: self.dhtmem_ram(),
12663 };
12664 defmt::write!(f, "{}", proxy)
12665 }
12666 }
12667 #[doc = "JPEG encoder, AC Huffman table 1"]
12668 #[repr(transparent)]
12669 #[derive(Copy, Clone, Eq, PartialEq)]
12670 pub struct HuffencAc110(pub u32);
12671 impl HuffencAc110 {
12672 #[doc = "DHTMem RAM"]
12673 #[inline(always)]
12674 pub const fn dhtmem_ram(&self) -> u32 {
12675 let val = (self.0 >> 0usize) & 0xffff_ffff;
12676 val as u32
12677 }
12678 #[doc = "DHTMem RAM"]
12679 #[inline(always)]
12680 pub fn set_dhtmem_ram(&mut self, val: u32) {
12681 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12682 }
12683 }
12684 impl Default for HuffencAc110 {
12685 #[inline(always)]
12686 fn default() -> HuffencAc110 {
12687 HuffencAc110(0)
12688 }
12689 }
12690 impl core::fmt::Debug for HuffencAc110 {
12691 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12692 f.debug_struct("HuffencAc110")
12693 .field("dhtmem_ram", &self.dhtmem_ram())
12694 .finish()
12695 }
12696 }
12697 #[cfg(feature = "defmt")]
12698 impl defmt::Format for HuffencAc110 {
12699 fn format(&self, f: defmt::Formatter) {
12700 #[derive(defmt :: Format)]
12701 struct HuffencAc110 {
12702 dhtmem_ram: u32,
12703 }
12704 let proxy = HuffencAc110 {
12705 dhtmem_ram: self.dhtmem_ram(),
12706 };
12707 defmt::write!(f, "{}", proxy)
12708 }
12709 }
12710 #[doc = "JPEG encoder, AC Huffman table 1"]
12711 #[repr(transparent)]
12712 #[derive(Copy, Clone, Eq, PartialEq)]
12713 pub struct HuffencAc111(pub u32);
12714 impl HuffencAc111 {
12715 #[doc = "DHTMem RAM"]
12716 #[inline(always)]
12717 pub const fn dhtmem_ram(&self) -> u32 {
12718 let val = (self.0 >> 0usize) & 0xffff_ffff;
12719 val as u32
12720 }
12721 #[doc = "DHTMem RAM"]
12722 #[inline(always)]
12723 pub fn set_dhtmem_ram(&mut self, val: u32) {
12724 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12725 }
12726 }
12727 impl Default for HuffencAc111 {
12728 #[inline(always)]
12729 fn default() -> HuffencAc111 {
12730 HuffencAc111(0)
12731 }
12732 }
12733 impl core::fmt::Debug for HuffencAc111 {
12734 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12735 f.debug_struct("HuffencAc111")
12736 .field("dhtmem_ram", &self.dhtmem_ram())
12737 .finish()
12738 }
12739 }
12740 #[cfg(feature = "defmt")]
12741 impl defmt::Format for HuffencAc111 {
12742 fn format(&self, f: defmt::Formatter) {
12743 #[derive(defmt :: Format)]
12744 struct HuffencAc111 {
12745 dhtmem_ram: u32,
12746 }
12747 let proxy = HuffencAc111 {
12748 dhtmem_ram: self.dhtmem_ram(),
12749 };
12750 defmt::write!(f, "{}", proxy)
12751 }
12752 }
12753 #[doc = "JPEG encoder, AC Huffman table 1"]
12754 #[repr(transparent)]
12755 #[derive(Copy, Clone, Eq, PartialEq)]
12756 pub struct HuffencAc112(pub u32);
12757 impl HuffencAc112 {
12758 #[doc = "DHTMem RAM"]
12759 #[inline(always)]
12760 pub const fn dhtmem_ram(&self) -> u32 {
12761 let val = (self.0 >> 0usize) & 0xffff_ffff;
12762 val as u32
12763 }
12764 #[doc = "DHTMem RAM"]
12765 #[inline(always)]
12766 pub fn set_dhtmem_ram(&mut self, val: u32) {
12767 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12768 }
12769 }
12770 impl Default for HuffencAc112 {
12771 #[inline(always)]
12772 fn default() -> HuffencAc112 {
12773 HuffencAc112(0)
12774 }
12775 }
12776 impl core::fmt::Debug for HuffencAc112 {
12777 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12778 f.debug_struct("HuffencAc112")
12779 .field("dhtmem_ram", &self.dhtmem_ram())
12780 .finish()
12781 }
12782 }
12783 #[cfg(feature = "defmt")]
12784 impl defmt::Format for HuffencAc112 {
12785 fn format(&self, f: defmt::Formatter) {
12786 #[derive(defmt :: Format)]
12787 struct HuffencAc112 {
12788 dhtmem_ram: u32,
12789 }
12790 let proxy = HuffencAc112 {
12791 dhtmem_ram: self.dhtmem_ram(),
12792 };
12793 defmt::write!(f, "{}", proxy)
12794 }
12795 }
12796 #[doc = "JPEG encoder, AC Huffman table 1"]
12797 #[repr(transparent)]
12798 #[derive(Copy, Clone, Eq, PartialEq)]
12799 pub struct HuffencAc113(pub u32);
12800 impl HuffencAc113 {
12801 #[doc = "DHTMem RAM"]
12802 #[inline(always)]
12803 pub const fn dhtmem_ram(&self) -> u32 {
12804 let val = (self.0 >> 0usize) & 0xffff_ffff;
12805 val as u32
12806 }
12807 #[doc = "DHTMem RAM"]
12808 #[inline(always)]
12809 pub fn set_dhtmem_ram(&mut self, val: u32) {
12810 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12811 }
12812 }
12813 impl Default for HuffencAc113 {
12814 #[inline(always)]
12815 fn default() -> HuffencAc113 {
12816 HuffencAc113(0)
12817 }
12818 }
12819 impl core::fmt::Debug for HuffencAc113 {
12820 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12821 f.debug_struct("HuffencAc113")
12822 .field("dhtmem_ram", &self.dhtmem_ram())
12823 .finish()
12824 }
12825 }
12826 #[cfg(feature = "defmt")]
12827 impl defmt::Format for HuffencAc113 {
12828 fn format(&self, f: defmt::Formatter) {
12829 #[derive(defmt :: Format)]
12830 struct HuffencAc113 {
12831 dhtmem_ram: u32,
12832 }
12833 let proxy = HuffencAc113 {
12834 dhtmem_ram: self.dhtmem_ram(),
12835 };
12836 defmt::write!(f, "{}", proxy)
12837 }
12838 }
12839 #[doc = "JPEG encoder, AC Huffman table 1"]
12840 #[repr(transparent)]
12841 #[derive(Copy, Clone, Eq, PartialEq)]
12842 pub struct HuffencAc114(pub u32);
12843 impl HuffencAc114 {
12844 #[doc = "DHTMem RAM"]
12845 #[inline(always)]
12846 pub const fn dhtmem_ram(&self) -> u32 {
12847 let val = (self.0 >> 0usize) & 0xffff_ffff;
12848 val as u32
12849 }
12850 #[doc = "DHTMem RAM"]
12851 #[inline(always)]
12852 pub fn set_dhtmem_ram(&mut self, val: u32) {
12853 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12854 }
12855 }
12856 impl Default for HuffencAc114 {
12857 #[inline(always)]
12858 fn default() -> HuffencAc114 {
12859 HuffencAc114(0)
12860 }
12861 }
12862 impl core::fmt::Debug for HuffencAc114 {
12863 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12864 f.debug_struct("HuffencAc114")
12865 .field("dhtmem_ram", &self.dhtmem_ram())
12866 .finish()
12867 }
12868 }
12869 #[cfg(feature = "defmt")]
12870 impl defmt::Format for HuffencAc114 {
12871 fn format(&self, f: defmt::Formatter) {
12872 #[derive(defmt :: Format)]
12873 struct HuffencAc114 {
12874 dhtmem_ram: u32,
12875 }
12876 let proxy = HuffencAc114 {
12877 dhtmem_ram: self.dhtmem_ram(),
12878 };
12879 defmt::write!(f, "{}", proxy)
12880 }
12881 }
12882 #[doc = "JPEG encoder, AC Huffman table 1"]
12883 #[repr(transparent)]
12884 #[derive(Copy, Clone, Eq, PartialEq)]
12885 pub struct HuffencAc115(pub u32);
12886 impl HuffencAc115 {
12887 #[doc = "DHTMem RAM"]
12888 #[inline(always)]
12889 pub const fn dhtmem_ram(&self) -> u32 {
12890 let val = (self.0 >> 0usize) & 0xffff_ffff;
12891 val as u32
12892 }
12893 #[doc = "DHTMem RAM"]
12894 #[inline(always)]
12895 pub fn set_dhtmem_ram(&mut self, val: u32) {
12896 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12897 }
12898 }
12899 impl Default for HuffencAc115 {
12900 #[inline(always)]
12901 fn default() -> HuffencAc115 {
12902 HuffencAc115(0)
12903 }
12904 }
12905 impl core::fmt::Debug for HuffencAc115 {
12906 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12907 f.debug_struct("HuffencAc115")
12908 .field("dhtmem_ram", &self.dhtmem_ram())
12909 .finish()
12910 }
12911 }
12912 #[cfg(feature = "defmt")]
12913 impl defmt::Format for HuffencAc115 {
12914 fn format(&self, f: defmt::Formatter) {
12915 #[derive(defmt :: Format)]
12916 struct HuffencAc115 {
12917 dhtmem_ram: u32,
12918 }
12919 let proxy = HuffencAc115 {
12920 dhtmem_ram: self.dhtmem_ram(),
12921 };
12922 defmt::write!(f, "{}", proxy)
12923 }
12924 }
12925 #[doc = "JPEG encoder, AC Huffman table 1"]
12926 #[repr(transparent)]
12927 #[derive(Copy, Clone, Eq, PartialEq)]
12928 pub struct HuffencAc116(pub u32);
12929 impl HuffencAc116 {
12930 #[doc = "DHTMem RAM"]
12931 #[inline(always)]
12932 pub const fn dhtmem_ram(&self) -> u32 {
12933 let val = (self.0 >> 0usize) & 0xffff_ffff;
12934 val as u32
12935 }
12936 #[doc = "DHTMem RAM"]
12937 #[inline(always)]
12938 pub fn set_dhtmem_ram(&mut self, val: u32) {
12939 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12940 }
12941 }
12942 impl Default for HuffencAc116 {
12943 #[inline(always)]
12944 fn default() -> HuffencAc116 {
12945 HuffencAc116(0)
12946 }
12947 }
12948 impl core::fmt::Debug for HuffencAc116 {
12949 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12950 f.debug_struct("HuffencAc116")
12951 .field("dhtmem_ram", &self.dhtmem_ram())
12952 .finish()
12953 }
12954 }
12955 #[cfg(feature = "defmt")]
12956 impl defmt::Format for HuffencAc116 {
12957 fn format(&self, f: defmt::Formatter) {
12958 #[derive(defmt :: Format)]
12959 struct HuffencAc116 {
12960 dhtmem_ram: u32,
12961 }
12962 let proxy = HuffencAc116 {
12963 dhtmem_ram: self.dhtmem_ram(),
12964 };
12965 defmt::write!(f, "{}", proxy)
12966 }
12967 }
12968 #[doc = "JPEG encoder, AC Huffman table 1"]
12969 #[repr(transparent)]
12970 #[derive(Copy, Clone, Eq, PartialEq)]
12971 pub struct HuffencAc117(pub u32);
12972 impl HuffencAc117 {
12973 #[doc = "DHTMem RAM"]
12974 #[inline(always)]
12975 pub const fn dhtmem_ram(&self) -> u32 {
12976 let val = (self.0 >> 0usize) & 0xffff_ffff;
12977 val as u32
12978 }
12979 #[doc = "DHTMem RAM"]
12980 #[inline(always)]
12981 pub fn set_dhtmem_ram(&mut self, val: u32) {
12982 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
12983 }
12984 }
12985 impl Default for HuffencAc117 {
12986 #[inline(always)]
12987 fn default() -> HuffencAc117 {
12988 HuffencAc117(0)
12989 }
12990 }
12991 impl core::fmt::Debug for HuffencAc117 {
12992 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
12993 f.debug_struct("HuffencAc117")
12994 .field("dhtmem_ram", &self.dhtmem_ram())
12995 .finish()
12996 }
12997 }
12998 #[cfg(feature = "defmt")]
12999 impl defmt::Format for HuffencAc117 {
13000 fn format(&self, f: defmt::Formatter) {
13001 #[derive(defmt :: Format)]
13002 struct HuffencAc117 {
13003 dhtmem_ram: u32,
13004 }
13005 let proxy = HuffencAc117 {
13006 dhtmem_ram: self.dhtmem_ram(),
13007 };
13008 defmt::write!(f, "{}", proxy)
13009 }
13010 }
13011 #[doc = "JPEG encoder, AC Huffman table 1"]
13012 #[repr(transparent)]
13013 #[derive(Copy, Clone, Eq, PartialEq)]
13014 pub struct HuffencAc118(pub u32);
13015 impl HuffencAc118 {
13016 #[doc = "DHTMem RAM"]
13017 #[inline(always)]
13018 pub const fn dhtmem_ram(&self) -> u32 {
13019 let val = (self.0 >> 0usize) & 0xffff_ffff;
13020 val as u32
13021 }
13022 #[doc = "DHTMem RAM"]
13023 #[inline(always)]
13024 pub fn set_dhtmem_ram(&mut self, val: u32) {
13025 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13026 }
13027 }
13028 impl Default for HuffencAc118 {
13029 #[inline(always)]
13030 fn default() -> HuffencAc118 {
13031 HuffencAc118(0)
13032 }
13033 }
13034 impl core::fmt::Debug for HuffencAc118 {
13035 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13036 f.debug_struct("HuffencAc118")
13037 .field("dhtmem_ram", &self.dhtmem_ram())
13038 .finish()
13039 }
13040 }
13041 #[cfg(feature = "defmt")]
13042 impl defmt::Format for HuffencAc118 {
13043 fn format(&self, f: defmt::Formatter) {
13044 #[derive(defmt :: Format)]
13045 struct HuffencAc118 {
13046 dhtmem_ram: u32,
13047 }
13048 let proxy = HuffencAc118 {
13049 dhtmem_ram: self.dhtmem_ram(),
13050 };
13051 defmt::write!(f, "{}", proxy)
13052 }
13053 }
13054 #[doc = "JPEG encoder, AC Huffman table 1"]
13055 #[repr(transparent)]
13056 #[derive(Copy, Clone, Eq, PartialEq)]
13057 pub struct HuffencAc119(pub u32);
13058 impl HuffencAc119 {
13059 #[doc = "DHTMem RAM"]
13060 #[inline(always)]
13061 pub const fn dhtmem_ram(&self) -> u32 {
13062 let val = (self.0 >> 0usize) & 0xffff_ffff;
13063 val as u32
13064 }
13065 #[doc = "DHTMem RAM"]
13066 #[inline(always)]
13067 pub fn set_dhtmem_ram(&mut self, val: u32) {
13068 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13069 }
13070 }
13071 impl Default for HuffencAc119 {
13072 #[inline(always)]
13073 fn default() -> HuffencAc119 {
13074 HuffencAc119(0)
13075 }
13076 }
13077 impl core::fmt::Debug for HuffencAc119 {
13078 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13079 f.debug_struct("HuffencAc119")
13080 .field("dhtmem_ram", &self.dhtmem_ram())
13081 .finish()
13082 }
13083 }
13084 #[cfg(feature = "defmt")]
13085 impl defmt::Format for HuffencAc119 {
13086 fn format(&self, f: defmt::Formatter) {
13087 #[derive(defmt :: Format)]
13088 struct HuffencAc119 {
13089 dhtmem_ram: u32,
13090 }
13091 let proxy = HuffencAc119 {
13092 dhtmem_ram: self.dhtmem_ram(),
13093 };
13094 defmt::write!(f, "{}", proxy)
13095 }
13096 }
13097 #[doc = "JPEG encoder, AC Huffman table 1"]
13098 #[repr(transparent)]
13099 #[derive(Copy, Clone, Eq, PartialEq)]
13100 pub struct HuffencAc12(pub u32);
13101 impl HuffencAc12 {
13102 #[doc = "DHTMem RAM"]
13103 #[inline(always)]
13104 pub const fn dhtmem_ram(&self) -> u32 {
13105 let val = (self.0 >> 0usize) & 0xffff_ffff;
13106 val as u32
13107 }
13108 #[doc = "DHTMem RAM"]
13109 #[inline(always)]
13110 pub fn set_dhtmem_ram(&mut self, val: u32) {
13111 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13112 }
13113 }
13114 impl Default for HuffencAc12 {
13115 #[inline(always)]
13116 fn default() -> HuffencAc12 {
13117 HuffencAc12(0)
13118 }
13119 }
13120 impl core::fmt::Debug for HuffencAc12 {
13121 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13122 f.debug_struct("HuffencAc12")
13123 .field("dhtmem_ram", &self.dhtmem_ram())
13124 .finish()
13125 }
13126 }
13127 #[cfg(feature = "defmt")]
13128 impl defmt::Format for HuffencAc12 {
13129 fn format(&self, f: defmt::Formatter) {
13130 #[derive(defmt :: Format)]
13131 struct HuffencAc12 {
13132 dhtmem_ram: u32,
13133 }
13134 let proxy = HuffencAc12 {
13135 dhtmem_ram: self.dhtmem_ram(),
13136 };
13137 defmt::write!(f, "{}", proxy)
13138 }
13139 }
13140 #[doc = "JPEG encoder, AC Huffman table 1"]
13141 #[repr(transparent)]
13142 #[derive(Copy, Clone, Eq, PartialEq)]
13143 pub struct HuffencAc120(pub u32);
13144 impl HuffencAc120 {
13145 #[doc = "DHTMem RAM"]
13146 #[inline(always)]
13147 pub const fn dhtmem_ram(&self) -> u32 {
13148 let val = (self.0 >> 0usize) & 0xffff_ffff;
13149 val as u32
13150 }
13151 #[doc = "DHTMem RAM"]
13152 #[inline(always)]
13153 pub fn set_dhtmem_ram(&mut self, val: u32) {
13154 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13155 }
13156 }
13157 impl Default for HuffencAc120 {
13158 #[inline(always)]
13159 fn default() -> HuffencAc120 {
13160 HuffencAc120(0)
13161 }
13162 }
13163 impl core::fmt::Debug for HuffencAc120 {
13164 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13165 f.debug_struct("HuffencAc120")
13166 .field("dhtmem_ram", &self.dhtmem_ram())
13167 .finish()
13168 }
13169 }
13170 #[cfg(feature = "defmt")]
13171 impl defmt::Format for HuffencAc120 {
13172 fn format(&self, f: defmt::Formatter) {
13173 #[derive(defmt :: Format)]
13174 struct HuffencAc120 {
13175 dhtmem_ram: u32,
13176 }
13177 let proxy = HuffencAc120 {
13178 dhtmem_ram: self.dhtmem_ram(),
13179 };
13180 defmt::write!(f, "{}", proxy)
13181 }
13182 }
13183 #[doc = "JPEG encoder, AC Huffman table 1"]
13184 #[repr(transparent)]
13185 #[derive(Copy, Clone, Eq, PartialEq)]
13186 pub struct HuffencAc121(pub u32);
13187 impl HuffencAc121 {
13188 #[doc = "DHTMem RAM"]
13189 #[inline(always)]
13190 pub const fn dhtmem_ram(&self) -> u32 {
13191 let val = (self.0 >> 0usize) & 0xffff_ffff;
13192 val as u32
13193 }
13194 #[doc = "DHTMem RAM"]
13195 #[inline(always)]
13196 pub fn set_dhtmem_ram(&mut self, val: u32) {
13197 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13198 }
13199 }
13200 impl Default for HuffencAc121 {
13201 #[inline(always)]
13202 fn default() -> HuffencAc121 {
13203 HuffencAc121(0)
13204 }
13205 }
13206 impl core::fmt::Debug for HuffencAc121 {
13207 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13208 f.debug_struct("HuffencAc121")
13209 .field("dhtmem_ram", &self.dhtmem_ram())
13210 .finish()
13211 }
13212 }
13213 #[cfg(feature = "defmt")]
13214 impl defmt::Format for HuffencAc121 {
13215 fn format(&self, f: defmt::Formatter) {
13216 #[derive(defmt :: Format)]
13217 struct HuffencAc121 {
13218 dhtmem_ram: u32,
13219 }
13220 let proxy = HuffencAc121 {
13221 dhtmem_ram: self.dhtmem_ram(),
13222 };
13223 defmt::write!(f, "{}", proxy)
13224 }
13225 }
13226 #[doc = "JPEG encoder, AC Huffman table 1"]
13227 #[repr(transparent)]
13228 #[derive(Copy, Clone, Eq, PartialEq)]
13229 pub struct HuffencAc122(pub u32);
13230 impl HuffencAc122 {
13231 #[doc = "DHTMem RAM"]
13232 #[inline(always)]
13233 pub const fn dhtmem_ram(&self) -> u32 {
13234 let val = (self.0 >> 0usize) & 0xffff_ffff;
13235 val as u32
13236 }
13237 #[doc = "DHTMem RAM"]
13238 #[inline(always)]
13239 pub fn set_dhtmem_ram(&mut self, val: u32) {
13240 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13241 }
13242 }
13243 impl Default for HuffencAc122 {
13244 #[inline(always)]
13245 fn default() -> HuffencAc122 {
13246 HuffencAc122(0)
13247 }
13248 }
13249 impl core::fmt::Debug for HuffencAc122 {
13250 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13251 f.debug_struct("HuffencAc122")
13252 .field("dhtmem_ram", &self.dhtmem_ram())
13253 .finish()
13254 }
13255 }
13256 #[cfg(feature = "defmt")]
13257 impl defmt::Format for HuffencAc122 {
13258 fn format(&self, f: defmt::Formatter) {
13259 #[derive(defmt :: Format)]
13260 struct HuffencAc122 {
13261 dhtmem_ram: u32,
13262 }
13263 let proxy = HuffencAc122 {
13264 dhtmem_ram: self.dhtmem_ram(),
13265 };
13266 defmt::write!(f, "{}", proxy)
13267 }
13268 }
13269 #[doc = "JPEG encoder, AC Huffman table 1"]
13270 #[repr(transparent)]
13271 #[derive(Copy, Clone, Eq, PartialEq)]
13272 pub struct HuffencAc123(pub u32);
13273 impl HuffencAc123 {
13274 #[doc = "DHTMem RAM"]
13275 #[inline(always)]
13276 pub const fn dhtmem_ram(&self) -> u32 {
13277 let val = (self.0 >> 0usize) & 0xffff_ffff;
13278 val as u32
13279 }
13280 #[doc = "DHTMem RAM"]
13281 #[inline(always)]
13282 pub fn set_dhtmem_ram(&mut self, val: u32) {
13283 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13284 }
13285 }
13286 impl Default for HuffencAc123 {
13287 #[inline(always)]
13288 fn default() -> HuffencAc123 {
13289 HuffencAc123(0)
13290 }
13291 }
13292 impl core::fmt::Debug for HuffencAc123 {
13293 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13294 f.debug_struct("HuffencAc123")
13295 .field("dhtmem_ram", &self.dhtmem_ram())
13296 .finish()
13297 }
13298 }
13299 #[cfg(feature = "defmt")]
13300 impl defmt::Format for HuffencAc123 {
13301 fn format(&self, f: defmt::Formatter) {
13302 #[derive(defmt :: Format)]
13303 struct HuffencAc123 {
13304 dhtmem_ram: u32,
13305 }
13306 let proxy = HuffencAc123 {
13307 dhtmem_ram: self.dhtmem_ram(),
13308 };
13309 defmt::write!(f, "{}", proxy)
13310 }
13311 }
13312 #[doc = "JPEG encoder, AC Huffman table 1"]
13313 #[repr(transparent)]
13314 #[derive(Copy, Clone, Eq, PartialEq)]
13315 pub struct HuffencAc124(pub u32);
13316 impl HuffencAc124 {
13317 #[doc = "DHTMem RAM"]
13318 #[inline(always)]
13319 pub const fn dhtmem_ram(&self) -> u32 {
13320 let val = (self.0 >> 0usize) & 0xffff_ffff;
13321 val as u32
13322 }
13323 #[doc = "DHTMem RAM"]
13324 #[inline(always)]
13325 pub fn set_dhtmem_ram(&mut self, val: u32) {
13326 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13327 }
13328 }
13329 impl Default for HuffencAc124 {
13330 #[inline(always)]
13331 fn default() -> HuffencAc124 {
13332 HuffencAc124(0)
13333 }
13334 }
13335 impl core::fmt::Debug for HuffencAc124 {
13336 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13337 f.debug_struct("HuffencAc124")
13338 .field("dhtmem_ram", &self.dhtmem_ram())
13339 .finish()
13340 }
13341 }
13342 #[cfg(feature = "defmt")]
13343 impl defmt::Format for HuffencAc124 {
13344 fn format(&self, f: defmt::Formatter) {
13345 #[derive(defmt :: Format)]
13346 struct HuffencAc124 {
13347 dhtmem_ram: u32,
13348 }
13349 let proxy = HuffencAc124 {
13350 dhtmem_ram: self.dhtmem_ram(),
13351 };
13352 defmt::write!(f, "{}", proxy)
13353 }
13354 }
13355 #[doc = "JPEG encoder, AC Huffman table 1"]
13356 #[repr(transparent)]
13357 #[derive(Copy, Clone, Eq, PartialEq)]
13358 pub struct HuffencAc125(pub u32);
13359 impl HuffencAc125 {
13360 #[doc = "DHTMem RAM"]
13361 #[inline(always)]
13362 pub const fn dhtmem_ram(&self) -> u32 {
13363 let val = (self.0 >> 0usize) & 0xffff_ffff;
13364 val as u32
13365 }
13366 #[doc = "DHTMem RAM"]
13367 #[inline(always)]
13368 pub fn set_dhtmem_ram(&mut self, val: u32) {
13369 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13370 }
13371 }
13372 impl Default for HuffencAc125 {
13373 #[inline(always)]
13374 fn default() -> HuffencAc125 {
13375 HuffencAc125(0)
13376 }
13377 }
13378 impl core::fmt::Debug for HuffencAc125 {
13379 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13380 f.debug_struct("HuffencAc125")
13381 .field("dhtmem_ram", &self.dhtmem_ram())
13382 .finish()
13383 }
13384 }
13385 #[cfg(feature = "defmt")]
13386 impl defmt::Format for HuffencAc125 {
13387 fn format(&self, f: defmt::Formatter) {
13388 #[derive(defmt :: Format)]
13389 struct HuffencAc125 {
13390 dhtmem_ram: u32,
13391 }
13392 let proxy = HuffencAc125 {
13393 dhtmem_ram: self.dhtmem_ram(),
13394 };
13395 defmt::write!(f, "{}", proxy)
13396 }
13397 }
13398 #[doc = "JPEG encoder, AC Huffman table 1"]
13399 #[repr(transparent)]
13400 #[derive(Copy, Clone, Eq, PartialEq)]
13401 pub struct HuffencAc126(pub u32);
13402 impl HuffencAc126 {
13403 #[doc = "DHTMem RAM"]
13404 #[inline(always)]
13405 pub const fn dhtmem_ram(&self) -> u32 {
13406 let val = (self.0 >> 0usize) & 0xffff_ffff;
13407 val as u32
13408 }
13409 #[doc = "DHTMem RAM"]
13410 #[inline(always)]
13411 pub fn set_dhtmem_ram(&mut self, val: u32) {
13412 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13413 }
13414 }
13415 impl Default for HuffencAc126 {
13416 #[inline(always)]
13417 fn default() -> HuffencAc126 {
13418 HuffencAc126(0)
13419 }
13420 }
13421 impl core::fmt::Debug for HuffencAc126 {
13422 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13423 f.debug_struct("HuffencAc126")
13424 .field("dhtmem_ram", &self.dhtmem_ram())
13425 .finish()
13426 }
13427 }
13428 #[cfg(feature = "defmt")]
13429 impl defmt::Format for HuffencAc126 {
13430 fn format(&self, f: defmt::Formatter) {
13431 #[derive(defmt :: Format)]
13432 struct HuffencAc126 {
13433 dhtmem_ram: u32,
13434 }
13435 let proxy = HuffencAc126 {
13436 dhtmem_ram: self.dhtmem_ram(),
13437 };
13438 defmt::write!(f, "{}", proxy)
13439 }
13440 }
13441 #[doc = "JPEG encoder, AC Huffman table 1"]
13442 #[repr(transparent)]
13443 #[derive(Copy, Clone, Eq, PartialEq)]
13444 pub struct HuffencAc127(pub u32);
13445 impl HuffencAc127 {
13446 #[doc = "DHTMem RAM"]
13447 #[inline(always)]
13448 pub const fn dhtmem_ram(&self) -> u32 {
13449 let val = (self.0 >> 0usize) & 0xffff_ffff;
13450 val as u32
13451 }
13452 #[doc = "DHTMem RAM"]
13453 #[inline(always)]
13454 pub fn set_dhtmem_ram(&mut self, val: u32) {
13455 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13456 }
13457 }
13458 impl Default for HuffencAc127 {
13459 #[inline(always)]
13460 fn default() -> HuffencAc127 {
13461 HuffencAc127(0)
13462 }
13463 }
13464 impl core::fmt::Debug for HuffencAc127 {
13465 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13466 f.debug_struct("HuffencAc127")
13467 .field("dhtmem_ram", &self.dhtmem_ram())
13468 .finish()
13469 }
13470 }
13471 #[cfg(feature = "defmt")]
13472 impl defmt::Format for HuffencAc127 {
13473 fn format(&self, f: defmt::Formatter) {
13474 #[derive(defmt :: Format)]
13475 struct HuffencAc127 {
13476 dhtmem_ram: u32,
13477 }
13478 let proxy = HuffencAc127 {
13479 dhtmem_ram: self.dhtmem_ram(),
13480 };
13481 defmt::write!(f, "{}", proxy)
13482 }
13483 }
13484 #[doc = "JPEG encoder, AC Huffman table 1"]
13485 #[repr(transparent)]
13486 #[derive(Copy, Clone, Eq, PartialEq)]
13487 pub struct HuffencAc128(pub u32);
13488 impl HuffencAc128 {
13489 #[doc = "DHTMem RAM"]
13490 #[inline(always)]
13491 pub const fn dhtmem_ram(&self) -> u32 {
13492 let val = (self.0 >> 0usize) & 0xffff_ffff;
13493 val as u32
13494 }
13495 #[doc = "DHTMem RAM"]
13496 #[inline(always)]
13497 pub fn set_dhtmem_ram(&mut self, val: u32) {
13498 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13499 }
13500 }
13501 impl Default for HuffencAc128 {
13502 #[inline(always)]
13503 fn default() -> HuffencAc128 {
13504 HuffencAc128(0)
13505 }
13506 }
13507 impl core::fmt::Debug for HuffencAc128 {
13508 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13509 f.debug_struct("HuffencAc128")
13510 .field("dhtmem_ram", &self.dhtmem_ram())
13511 .finish()
13512 }
13513 }
13514 #[cfg(feature = "defmt")]
13515 impl defmt::Format for HuffencAc128 {
13516 fn format(&self, f: defmt::Formatter) {
13517 #[derive(defmt :: Format)]
13518 struct HuffencAc128 {
13519 dhtmem_ram: u32,
13520 }
13521 let proxy = HuffencAc128 {
13522 dhtmem_ram: self.dhtmem_ram(),
13523 };
13524 defmt::write!(f, "{}", proxy)
13525 }
13526 }
13527 #[doc = "JPEG encoder, AC Huffman table 1"]
13528 #[repr(transparent)]
13529 #[derive(Copy, Clone, Eq, PartialEq)]
13530 pub struct HuffencAc129(pub u32);
13531 impl HuffencAc129 {
13532 #[doc = "DHTMem RAM"]
13533 #[inline(always)]
13534 pub const fn dhtmem_ram(&self) -> u32 {
13535 let val = (self.0 >> 0usize) & 0xffff_ffff;
13536 val as u32
13537 }
13538 #[doc = "DHTMem RAM"]
13539 #[inline(always)]
13540 pub fn set_dhtmem_ram(&mut self, val: u32) {
13541 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13542 }
13543 }
13544 impl Default for HuffencAc129 {
13545 #[inline(always)]
13546 fn default() -> HuffencAc129 {
13547 HuffencAc129(0)
13548 }
13549 }
13550 impl core::fmt::Debug for HuffencAc129 {
13551 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13552 f.debug_struct("HuffencAc129")
13553 .field("dhtmem_ram", &self.dhtmem_ram())
13554 .finish()
13555 }
13556 }
13557 #[cfg(feature = "defmt")]
13558 impl defmt::Format for HuffencAc129 {
13559 fn format(&self, f: defmt::Formatter) {
13560 #[derive(defmt :: Format)]
13561 struct HuffencAc129 {
13562 dhtmem_ram: u32,
13563 }
13564 let proxy = HuffencAc129 {
13565 dhtmem_ram: self.dhtmem_ram(),
13566 };
13567 defmt::write!(f, "{}", proxy)
13568 }
13569 }
13570 #[doc = "JPEG encoder, AC Huffman table 1"]
13571 #[repr(transparent)]
13572 #[derive(Copy, Clone, Eq, PartialEq)]
13573 pub struct HuffencAc13(pub u32);
13574 impl HuffencAc13 {
13575 #[doc = "DHTMem RAM"]
13576 #[inline(always)]
13577 pub const fn dhtmem_ram(&self) -> u32 {
13578 let val = (self.0 >> 0usize) & 0xffff_ffff;
13579 val as u32
13580 }
13581 #[doc = "DHTMem RAM"]
13582 #[inline(always)]
13583 pub fn set_dhtmem_ram(&mut self, val: u32) {
13584 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13585 }
13586 }
13587 impl Default for HuffencAc13 {
13588 #[inline(always)]
13589 fn default() -> HuffencAc13 {
13590 HuffencAc13(0)
13591 }
13592 }
13593 impl core::fmt::Debug for HuffencAc13 {
13594 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13595 f.debug_struct("HuffencAc13")
13596 .field("dhtmem_ram", &self.dhtmem_ram())
13597 .finish()
13598 }
13599 }
13600 #[cfg(feature = "defmt")]
13601 impl defmt::Format for HuffencAc13 {
13602 fn format(&self, f: defmt::Formatter) {
13603 #[derive(defmt :: Format)]
13604 struct HuffencAc13 {
13605 dhtmem_ram: u32,
13606 }
13607 let proxy = HuffencAc13 {
13608 dhtmem_ram: self.dhtmem_ram(),
13609 };
13610 defmt::write!(f, "{}", proxy)
13611 }
13612 }
13613 #[doc = "JPEG encoder, AC Huffman table 1"]
13614 #[repr(transparent)]
13615 #[derive(Copy, Clone, Eq, PartialEq)]
13616 pub struct HuffencAc130(pub u32);
13617 impl HuffencAc130 {
13618 #[doc = "DHTMem RAM"]
13619 #[inline(always)]
13620 pub const fn dhtmem_ram(&self) -> u32 {
13621 let val = (self.0 >> 0usize) & 0xffff_ffff;
13622 val as u32
13623 }
13624 #[doc = "DHTMem RAM"]
13625 #[inline(always)]
13626 pub fn set_dhtmem_ram(&mut self, val: u32) {
13627 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13628 }
13629 }
13630 impl Default for HuffencAc130 {
13631 #[inline(always)]
13632 fn default() -> HuffencAc130 {
13633 HuffencAc130(0)
13634 }
13635 }
13636 impl core::fmt::Debug for HuffencAc130 {
13637 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13638 f.debug_struct("HuffencAc130")
13639 .field("dhtmem_ram", &self.dhtmem_ram())
13640 .finish()
13641 }
13642 }
13643 #[cfg(feature = "defmt")]
13644 impl defmt::Format for HuffencAc130 {
13645 fn format(&self, f: defmt::Formatter) {
13646 #[derive(defmt :: Format)]
13647 struct HuffencAc130 {
13648 dhtmem_ram: u32,
13649 }
13650 let proxy = HuffencAc130 {
13651 dhtmem_ram: self.dhtmem_ram(),
13652 };
13653 defmt::write!(f, "{}", proxy)
13654 }
13655 }
13656 #[doc = "JPEG encoder, AC Huffman table 1"]
13657 #[repr(transparent)]
13658 #[derive(Copy, Clone, Eq, PartialEq)]
13659 pub struct HuffencAc131(pub u32);
13660 impl HuffencAc131 {
13661 #[doc = "DHTMem RAM"]
13662 #[inline(always)]
13663 pub const fn dhtmem_ram(&self) -> u32 {
13664 let val = (self.0 >> 0usize) & 0xffff_ffff;
13665 val as u32
13666 }
13667 #[doc = "DHTMem RAM"]
13668 #[inline(always)]
13669 pub fn set_dhtmem_ram(&mut self, val: u32) {
13670 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13671 }
13672 }
13673 impl Default for HuffencAc131 {
13674 #[inline(always)]
13675 fn default() -> HuffencAc131 {
13676 HuffencAc131(0)
13677 }
13678 }
13679 impl core::fmt::Debug for HuffencAc131 {
13680 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13681 f.debug_struct("HuffencAc131")
13682 .field("dhtmem_ram", &self.dhtmem_ram())
13683 .finish()
13684 }
13685 }
13686 #[cfg(feature = "defmt")]
13687 impl defmt::Format for HuffencAc131 {
13688 fn format(&self, f: defmt::Formatter) {
13689 #[derive(defmt :: Format)]
13690 struct HuffencAc131 {
13691 dhtmem_ram: u32,
13692 }
13693 let proxy = HuffencAc131 {
13694 dhtmem_ram: self.dhtmem_ram(),
13695 };
13696 defmt::write!(f, "{}", proxy)
13697 }
13698 }
13699 #[doc = "JPEG encoder, AC Huffman table 1"]
13700 #[repr(transparent)]
13701 #[derive(Copy, Clone, Eq, PartialEq)]
13702 pub struct HuffencAc132(pub u32);
13703 impl HuffencAc132 {
13704 #[doc = "DHTMem RAM"]
13705 #[inline(always)]
13706 pub const fn dhtmem_ram(&self) -> u32 {
13707 let val = (self.0 >> 0usize) & 0xffff_ffff;
13708 val as u32
13709 }
13710 #[doc = "DHTMem RAM"]
13711 #[inline(always)]
13712 pub fn set_dhtmem_ram(&mut self, val: u32) {
13713 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13714 }
13715 }
13716 impl Default for HuffencAc132 {
13717 #[inline(always)]
13718 fn default() -> HuffencAc132 {
13719 HuffencAc132(0)
13720 }
13721 }
13722 impl core::fmt::Debug for HuffencAc132 {
13723 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13724 f.debug_struct("HuffencAc132")
13725 .field("dhtmem_ram", &self.dhtmem_ram())
13726 .finish()
13727 }
13728 }
13729 #[cfg(feature = "defmt")]
13730 impl defmt::Format for HuffencAc132 {
13731 fn format(&self, f: defmt::Formatter) {
13732 #[derive(defmt :: Format)]
13733 struct HuffencAc132 {
13734 dhtmem_ram: u32,
13735 }
13736 let proxy = HuffencAc132 {
13737 dhtmem_ram: self.dhtmem_ram(),
13738 };
13739 defmt::write!(f, "{}", proxy)
13740 }
13741 }
13742 #[doc = "JPEG encoder, AC Huffman table 1"]
13743 #[repr(transparent)]
13744 #[derive(Copy, Clone, Eq, PartialEq)]
13745 pub struct HuffencAc133(pub u32);
13746 impl HuffencAc133 {
13747 #[doc = "DHTMem RAM"]
13748 #[inline(always)]
13749 pub const fn dhtmem_ram(&self) -> u32 {
13750 let val = (self.0 >> 0usize) & 0xffff_ffff;
13751 val as u32
13752 }
13753 #[doc = "DHTMem RAM"]
13754 #[inline(always)]
13755 pub fn set_dhtmem_ram(&mut self, val: u32) {
13756 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13757 }
13758 }
13759 impl Default for HuffencAc133 {
13760 #[inline(always)]
13761 fn default() -> HuffencAc133 {
13762 HuffencAc133(0)
13763 }
13764 }
13765 impl core::fmt::Debug for HuffencAc133 {
13766 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13767 f.debug_struct("HuffencAc133")
13768 .field("dhtmem_ram", &self.dhtmem_ram())
13769 .finish()
13770 }
13771 }
13772 #[cfg(feature = "defmt")]
13773 impl defmt::Format for HuffencAc133 {
13774 fn format(&self, f: defmt::Formatter) {
13775 #[derive(defmt :: Format)]
13776 struct HuffencAc133 {
13777 dhtmem_ram: u32,
13778 }
13779 let proxy = HuffencAc133 {
13780 dhtmem_ram: self.dhtmem_ram(),
13781 };
13782 defmt::write!(f, "{}", proxy)
13783 }
13784 }
13785 #[doc = "JPEG encoder, AC Huffman table 1"]
13786 #[repr(transparent)]
13787 #[derive(Copy, Clone, Eq, PartialEq)]
13788 pub struct HuffencAc134(pub u32);
13789 impl HuffencAc134 {
13790 #[doc = "DHTMem RAM"]
13791 #[inline(always)]
13792 pub const fn dhtmem_ram(&self) -> u32 {
13793 let val = (self.0 >> 0usize) & 0xffff_ffff;
13794 val as u32
13795 }
13796 #[doc = "DHTMem RAM"]
13797 #[inline(always)]
13798 pub fn set_dhtmem_ram(&mut self, val: u32) {
13799 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13800 }
13801 }
13802 impl Default for HuffencAc134 {
13803 #[inline(always)]
13804 fn default() -> HuffencAc134 {
13805 HuffencAc134(0)
13806 }
13807 }
13808 impl core::fmt::Debug for HuffencAc134 {
13809 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13810 f.debug_struct("HuffencAc134")
13811 .field("dhtmem_ram", &self.dhtmem_ram())
13812 .finish()
13813 }
13814 }
13815 #[cfg(feature = "defmt")]
13816 impl defmt::Format for HuffencAc134 {
13817 fn format(&self, f: defmt::Formatter) {
13818 #[derive(defmt :: Format)]
13819 struct HuffencAc134 {
13820 dhtmem_ram: u32,
13821 }
13822 let proxy = HuffencAc134 {
13823 dhtmem_ram: self.dhtmem_ram(),
13824 };
13825 defmt::write!(f, "{}", proxy)
13826 }
13827 }
13828 #[doc = "JPEG encoder, AC Huffman table 1"]
13829 #[repr(transparent)]
13830 #[derive(Copy, Clone, Eq, PartialEq)]
13831 pub struct HuffencAc135(pub u32);
13832 impl HuffencAc135 {
13833 #[doc = "DHTMem RAM"]
13834 #[inline(always)]
13835 pub const fn dhtmem_ram(&self) -> u32 {
13836 let val = (self.0 >> 0usize) & 0xffff_ffff;
13837 val as u32
13838 }
13839 #[doc = "DHTMem RAM"]
13840 #[inline(always)]
13841 pub fn set_dhtmem_ram(&mut self, val: u32) {
13842 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13843 }
13844 }
13845 impl Default for HuffencAc135 {
13846 #[inline(always)]
13847 fn default() -> HuffencAc135 {
13848 HuffencAc135(0)
13849 }
13850 }
13851 impl core::fmt::Debug for HuffencAc135 {
13852 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13853 f.debug_struct("HuffencAc135")
13854 .field("dhtmem_ram", &self.dhtmem_ram())
13855 .finish()
13856 }
13857 }
13858 #[cfg(feature = "defmt")]
13859 impl defmt::Format for HuffencAc135 {
13860 fn format(&self, f: defmt::Formatter) {
13861 #[derive(defmt :: Format)]
13862 struct HuffencAc135 {
13863 dhtmem_ram: u32,
13864 }
13865 let proxy = HuffencAc135 {
13866 dhtmem_ram: self.dhtmem_ram(),
13867 };
13868 defmt::write!(f, "{}", proxy)
13869 }
13870 }
13871 #[doc = "JPEG encoder, AC Huffman table 1"]
13872 #[repr(transparent)]
13873 #[derive(Copy, Clone, Eq, PartialEq)]
13874 pub struct HuffencAc136(pub u32);
13875 impl HuffencAc136 {
13876 #[doc = "DHTMem RAM"]
13877 #[inline(always)]
13878 pub const fn dhtmem_ram(&self) -> u32 {
13879 let val = (self.0 >> 0usize) & 0xffff_ffff;
13880 val as u32
13881 }
13882 #[doc = "DHTMem RAM"]
13883 #[inline(always)]
13884 pub fn set_dhtmem_ram(&mut self, val: u32) {
13885 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13886 }
13887 }
13888 impl Default for HuffencAc136 {
13889 #[inline(always)]
13890 fn default() -> HuffencAc136 {
13891 HuffencAc136(0)
13892 }
13893 }
13894 impl core::fmt::Debug for HuffencAc136 {
13895 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13896 f.debug_struct("HuffencAc136")
13897 .field("dhtmem_ram", &self.dhtmem_ram())
13898 .finish()
13899 }
13900 }
13901 #[cfg(feature = "defmt")]
13902 impl defmt::Format for HuffencAc136 {
13903 fn format(&self, f: defmt::Formatter) {
13904 #[derive(defmt :: Format)]
13905 struct HuffencAc136 {
13906 dhtmem_ram: u32,
13907 }
13908 let proxy = HuffencAc136 {
13909 dhtmem_ram: self.dhtmem_ram(),
13910 };
13911 defmt::write!(f, "{}", proxy)
13912 }
13913 }
13914 #[doc = "JPEG encoder, AC Huffman table 1"]
13915 #[repr(transparent)]
13916 #[derive(Copy, Clone, Eq, PartialEq)]
13917 pub struct HuffencAc137(pub u32);
13918 impl HuffencAc137 {
13919 #[doc = "DHTMem RAM"]
13920 #[inline(always)]
13921 pub const fn dhtmem_ram(&self) -> u32 {
13922 let val = (self.0 >> 0usize) & 0xffff_ffff;
13923 val as u32
13924 }
13925 #[doc = "DHTMem RAM"]
13926 #[inline(always)]
13927 pub fn set_dhtmem_ram(&mut self, val: u32) {
13928 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13929 }
13930 }
13931 impl Default for HuffencAc137 {
13932 #[inline(always)]
13933 fn default() -> HuffencAc137 {
13934 HuffencAc137(0)
13935 }
13936 }
13937 impl core::fmt::Debug for HuffencAc137 {
13938 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13939 f.debug_struct("HuffencAc137")
13940 .field("dhtmem_ram", &self.dhtmem_ram())
13941 .finish()
13942 }
13943 }
13944 #[cfg(feature = "defmt")]
13945 impl defmt::Format for HuffencAc137 {
13946 fn format(&self, f: defmt::Formatter) {
13947 #[derive(defmt :: Format)]
13948 struct HuffencAc137 {
13949 dhtmem_ram: u32,
13950 }
13951 let proxy = HuffencAc137 {
13952 dhtmem_ram: self.dhtmem_ram(),
13953 };
13954 defmt::write!(f, "{}", proxy)
13955 }
13956 }
13957 #[doc = "JPEG encoder, AC Huffman table 1"]
13958 #[repr(transparent)]
13959 #[derive(Copy, Clone, Eq, PartialEq)]
13960 pub struct HuffencAc138(pub u32);
13961 impl HuffencAc138 {
13962 #[doc = "DHTMem RAM"]
13963 #[inline(always)]
13964 pub const fn dhtmem_ram(&self) -> u32 {
13965 let val = (self.0 >> 0usize) & 0xffff_ffff;
13966 val as u32
13967 }
13968 #[doc = "DHTMem RAM"]
13969 #[inline(always)]
13970 pub fn set_dhtmem_ram(&mut self, val: u32) {
13971 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
13972 }
13973 }
13974 impl Default for HuffencAc138 {
13975 #[inline(always)]
13976 fn default() -> HuffencAc138 {
13977 HuffencAc138(0)
13978 }
13979 }
13980 impl core::fmt::Debug for HuffencAc138 {
13981 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
13982 f.debug_struct("HuffencAc138")
13983 .field("dhtmem_ram", &self.dhtmem_ram())
13984 .finish()
13985 }
13986 }
13987 #[cfg(feature = "defmt")]
13988 impl defmt::Format for HuffencAc138 {
13989 fn format(&self, f: defmt::Formatter) {
13990 #[derive(defmt :: Format)]
13991 struct HuffencAc138 {
13992 dhtmem_ram: u32,
13993 }
13994 let proxy = HuffencAc138 {
13995 dhtmem_ram: self.dhtmem_ram(),
13996 };
13997 defmt::write!(f, "{}", proxy)
13998 }
13999 }
14000 #[doc = "JPEG encoder, AC Huffman table 1"]
14001 #[repr(transparent)]
14002 #[derive(Copy, Clone, Eq, PartialEq)]
14003 pub struct HuffencAc139(pub u32);
14004 impl HuffencAc139 {
14005 #[doc = "DHTMem RAM"]
14006 #[inline(always)]
14007 pub const fn dhtmem_ram(&self) -> u32 {
14008 let val = (self.0 >> 0usize) & 0xffff_ffff;
14009 val as u32
14010 }
14011 #[doc = "DHTMem RAM"]
14012 #[inline(always)]
14013 pub fn set_dhtmem_ram(&mut self, val: u32) {
14014 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14015 }
14016 }
14017 impl Default for HuffencAc139 {
14018 #[inline(always)]
14019 fn default() -> HuffencAc139 {
14020 HuffencAc139(0)
14021 }
14022 }
14023 impl core::fmt::Debug for HuffencAc139 {
14024 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14025 f.debug_struct("HuffencAc139")
14026 .field("dhtmem_ram", &self.dhtmem_ram())
14027 .finish()
14028 }
14029 }
14030 #[cfg(feature = "defmt")]
14031 impl defmt::Format for HuffencAc139 {
14032 fn format(&self, f: defmt::Formatter) {
14033 #[derive(defmt :: Format)]
14034 struct HuffencAc139 {
14035 dhtmem_ram: u32,
14036 }
14037 let proxy = HuffencAc139 {
14038 dhtmem_ram: self.dhtmem_ram(),
14039 };
14040 defmt::write!(f, "{}", proxy)
14041 }
14042 }
14043 #[doc = "JPEG encoder, AC Huffman table 1"]
14044 #[repr(transparent)]
14045 #[derive(Copy, Clone, Eq, PartialEq)]
14046 pub struct HuffencAc14(pub u32);
14047 impl HuffencAc14 {
14048 #[doc = "DHTMem RAM"]
14049 #[inline(always)]
14050 pub const fn dhtmem_ram(&self) -> u32 {
14051 let val = (self.0 >> 0usize) & 0xffff_ffff;
14052 val as u32
14053 }
14054 #[doc = "DHTMem RAM"]
14055 #[inline(always)]
14056 pub fn set_dhtmem_ram(&mut self, val: u32) {
14057 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14058 }
14059 }
14060 impl Default for HuffencAc14 {
14061 #[inline(always)]
14062 fn default() -> HuffencAc14 {
14063 HuffencAc14(0)
14064 }
14065 }
14066 impl core::fmt::Debug for HuffencAc14 {
14067 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14068 f.debug_struct("HuffencAc14")
14069 .field("dhtmem_ram", &self.dhtmem_ram())
14070 .finish()
14071 }
14072 }
14073 #[cfg(feature = "defmt")]
14074 impl defmt::Format for HuffencAc14 {
14075 fn format(&self, f: defmt::Formatter) {
14076 #[derive(defmt :: Format)]
14077 struct HuffencAc14 {
14078 dhtmem_ram: u32,
14079 }
14080 let proxy = HuffencAc14 {
14081 dhtmem_ram: self.dhtmem_ram(),
14082 };
14083 defmt::write!(f, "{}", proxy)
14084 }
14085 }
14086 #[doc = "JPEG encoder, AC Huffman table 1"]
14087 #[repr(transparent)]
14088 #[derive(Copy, Clone, Eq, PartialEq)]
14089 pub struct HuffencAc140(pub u32);
14090 impl HuffencAc140 {
14091 #[doc = "DHTMem RAM"]
14092 #[inline(always)]
14093 pub const fn dhtmem_ram(&self) -> u32 {
14094 let val = (self.0 >> 0usize) & 0xffff_ffff;
14095 val as u32
14096 }
14097 #[doc = "DHTMem RAM"]
14098 #[inline(always)]
14099 pub fn set_dhtmem_ram(&mut self, val: u32) {
14100 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14101 }
14102 }
14103 impl Default for HuffencAc140 {
14104 #[inline(always)]
14105 fn default() -> HuffencAc140 {
14106 HuffencAc140(0)
14107 }
14108 }
14109 impl core::fmt::Debug for HuffencAc140 {
14110 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14111 f.debug_struct("HuffencAc140")
14112 .field("dhtmem_ram", &self.dhtmem_ram())
14113 .finish()
14114 }
14115 }
14116 #[cfg(feature = "defmt")]
14117 impl defmt::Format for HuffencAc140 {
14118 fn format(&self, f: defmt::Formatter) {
14119 #[derive(defmt :: Format)]
14120 struct HuffencAc140 {
14121 dhtmem_ram: u32,
14122 }
14123 let proxy = HuffencAc140 {
14124 dhtmem_ram: self.dhtmem_ram(),
14125 };
14126 defmt::write!(f, "{}", proxy)
14127 }
14128 }
14129 #[doc = "JPEG encoder, AC Huffman table 1"]
14130 #[repr(transparent)]
14131 #[derive(Copy, Clone, Eq, PartialEq)]
14132 pub struct HuffencAc141(pub u32);
14133 impl HuffencAc141 {
14134 #[doc = "DHTMem RAM"]
14135 #[inline(always)]
14136 pub const fn dhtmem_ram(&self) -> u32 {
14137 let val = (self.0 >> 0usize) & 0xffff_ffff;
14138 val as u32
14139 }
14140 #[doc = "DHTMem RAM"]
14141 #[inline(always)]
14142 pub fn set_dhtmem_ram(&mut self, val: u32) {
14143 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14144 }
14145 }
14146 impl Default for HuffencAc141 {
14147 #[inline(always)]
14148 fn default() -> HuffencAc141 {
14149 HuffencAc141(0)
14150 }
14151 }
14152 impl core::fmt::Debug for HuffencAc141 {
14153 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14154 f.debug_struct("HuffencAc141")
14155 .field("dhtmem_ram", &self.dhtmem_ram())
14156 .finish()
14157 }
14158 }
14159 #[cfg(feature = "defmt")]
14160 impl defmt::Format for HuffencAc141 {
14161 fn format(&self, f: defmt::Formatter) {
14162 #[derive(defmt :: Format)]
14163 struct HuffencAc141 {
14164 dhtmem_ram: u32,
14165 }
14166 let proxy = HuffencAc141 {
14167 dhtmem_ram: self.dhtmem_ram(),
14168 };
14169 defmt::write!(f, "{}", proxy)
14170 }
14171 }
14172 #[doc = "JPEG encoder, AC Huffman table 1"]
14173 #[repr(transparent)]
14174 #[derive(Copy, Clone, Eq, PartialEq)]
14175 pub struct HuffencAc142(pub u32);
14176 impl HuffencAc142 {
14177 #[doc = "DHTMem RAM"]
14178 #[inline(always)]
14179 pub const fn dhtmem_ram(&self) -> u32 {
14180 let val = (self.0 >> 0usize) & 0xffff_ffff;
14181 val as u32
14182 }
14183 #[doc = "DHTMem RAM"]
14184 #[inline(always)]
14185 pub fn set_dhtmem_ram(&mut self, val: u32) {
14186 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14187 }
14188 }
14189 impl Default for HuffencAc142 {
14190 #[inline(always)]
14191 fn default() -> HuffencAc142 {
14192 HuffencAc142(0)
14193 }
14194 }
14195 impl core::fmt::Debug for HuffencAc142 {
14196 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14197 f.debug_struct("HuffencAc142")
14198 .field("dhtmem_ram", &self.dhtmem_ram())
14199 .finish()
14200 }
14201 }
14202 #[cfg(feature = "defmt")]
14203 impl defmt::Format for HuffencAc142 {
14204 fn format(&self, f: defmt::Formatter) {
14205 #[derive(defmt :: Format)]
14206 struct HuffencAc142 {
14207 dhtmem_ram: u32,
14208 }
14209 let proxy = HuffencAc142 {
14210 dhtmem_ram: self.dhtmem_ram(),
14211 };
14212 defmt::write!(f, "{}", proxy)
14213 }
14214 }
14215 #[doc = "JPEG encoder, AC Huffman table 1"]
14216 #[repr(transparent)]
14217 #[derive(Copy, Clone, Eq, PartialEq)]
14218 pub struct HuffencAc143(pub u32);
14219 impl HuffencAc143 {
14220 #[doc = "DHTMem RAM"]
14221 #[inline(always)]
14222 pub const fn dhtmem_ram(&self) -> u32 {
14223 let val = (self.0 >> 0usize) & 0xffff_ffff;
14224 val as u32
14225 }
14226 #[doc = "DHTMem RAM"]
14227 #[inline(always)]
14228 pub fn set_dhtmem_ram(&mut self, val: u32) {
14229 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14230 }
14231 }
14232 impl Default for HuffencAc143 {
14233 #[inline(always)]
14234 fn default() -> HuffencAc143 {
14235 HuffencAc143(0)
14236 }
14237 }
14238 impl core::fmt::Debug for HuffencAc143 {
14239 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14240 f.debug_struct("HuffencAc143")
14241 .field("dhtmem_ram", &self.dhtmem_ram())
14242 .finish()
14243 }
14244 }
14245 #[cfg(feature = "defmt")]
14246 impl defmt::Format for HuffencAc143 {
14247 fn format(&self, f: defmt::Formatter) {
14248 #[derive(defmt :: Format)]
14249 struct HuffencAc143 {
14250 dhtmem_ram: u32,
14251 }
14252 let proxy = HuffencAc143 {
14253 dhtmem_ram: self.dhtmem_ram(),
14254 };
14255 defmt::write!(f, "{}", proxy)
14256 }
14257 }
14258 #[doc = "JPEG encoder, AC Huffman table 1"]
14259 #[repr(transparent)]
14260 #[derive(Copy, Clone, Eq, PartialEq)]
14261 pub struct HuffencAc144(pub u32);
14262 impl HuffencAc144 {
14263 #[doc = "DHTMem RAM"]
14264 #[inline(always)]
14265 pub const fn dhtmem_ram(&self) -> u32 {
14266 let val = (self.0 >> 0usize) & 0xffff_ffff;
14267 val as u32
14268 }
14269 #[doc = "DHTMem RAM"]
14270 #[inline(always)]
14271 pub fn set_dhtmem_ram(&mut self, val: u32) {
14272 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14273 }
14274 }
14275 impl Default for HuffencAc144 {
14276 #[inline(always)]
14277 fn default() -> HuffencAc144 {
14278 HuffencAc144(0)
14279 }
14280 }
14281 impl core::fmt::Debug for HuffencAc144 {
14282 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14283 f.debug_struct("HuffencAc144")
14284 .field("dhtmem_ram", &self.dhtmem_ram())
14285 .finish()
14286 }
14287 }
14288 #[cfg(feature = "defmt")]
14289 impl defmt::Format for HuffencAc144 {
14290 fn format(&self, f: defmt::Formatter) {
14291 #[derive(defmt :: Format)]
14292 struct HuffencAc144 {
14293 dhtmem_ram: u32,
14294 }
14295 let proxy = HuffencAc144 {
14296 dhtmem_ram: self.dhtmem_ram(),
14297 };
14298 defmt::write!(f, "{}", proxy)
14299 }
14300 }
14301 #[doc = "JPEG encoder, AC Huffman table 1"]
14302 #[repr(transparent)]
14303 #[derive(Copy, Clone, Eq, PartialEq)]
14304 pub struct HuffencAc145(pub u32);
14305 impl HuffencAc145 {
14306 #[doc = "DHTMem RAM"]
14307 #[inline(always)]
14308 pub const fn dhtmem_ram(&self) -> u32 {
14309 let val = (self.0 >> 0usize) & 0xffff_ffff;
14310 val as u32
14311 }
14312 #[doc = "DHTMem RAM"]
14313 #[inline(always)]
14314 pub fn set_dhtmem_ram(&mut self, val: u32) {
14315 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14316 }
14317 }
14318 impl Default for HuffencAc145 {
14319 #[inline(always)]
14320 fn default() -> HuffencAc145 {
14321 HuffencAc145(0)
14322 }
14323 }
14324 impl core::fmt::Debug for HuffencAc145 {
14325 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14326 f.debug_struct("HuffencAc145")
14327 .field("dhtmem_ram", &self.dhtmem_ram())
14328 .finish()
14329 }
14330 }
14331 #[cfg(feature = "defmt")]
14332 impl defmt::Format for HuffencAc145 {
14333 fn format(&self, f: defmt::Formatter) {
14334 #[derive(defmt :: Format)]
14335 struct HuffencAc145 {
14336 dhtmem_ram: u32,
14337 }
14338 let proxy = HuffencAc145 {
14339 dhtmem_ram: self.dhtmem_ram(),
14340 };
14341 defmt::write!(f, "{}", proxy)
14342 }
14343 }
14344 #[doc = "JPEG encoder, AC Huffman table 1"]
14345 #[repr(transparent)]
14346 #[derive(Copy, Clone, Eq, PartialEq)]
14347 pub struct HuffencAc146(pub u32);
14348 impl HuffencAc146 {
14349 #[doc = "DHTMem RAM"]
14350 #[inline(always)]
14351 pub const fn dhtmem_ram(&self) -> u32 {
14352 let val = (self.0 >> 0usize) & 0xffff_ffff;
14353 val as u32
14354 }
14355 #[doc = "DHTMem RAM"]
14356 #[inline(always)]
14357 pub fn set_dhtmem_ram(&mut self, val: u32) {
14358 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14359 }
14360 }
14361 impl Default for HuffencAc146 {
14362 #[inline(always)]
14363 fn default() -> HuffencAc146 {
14364 HuffencAc146(0)
14365 }
14366 }
14367 impl core::fmt::Debug for HuffencAc146 {
14368 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14369 f.debug_struct("HuffencAc146")
14370 .field("dhtmem_ram", &self.dhtmem_ram())
14371 .finish()
14372 }
14373 }
14374 #[cfg(feature = "defmt")]
14375 impl defmt::Format for HuffencAc146 {
14376 fn format(&self, f: defmt::Formatter) {
14377 #[derive(defmt :: Format)]
14378 struct HuffencAc146 {
14379 dhtmem_ram: u32,
14380 }
14381 let proxy = HuffencAc146 {
14382 dhtmem_ram: self.dhtmem_ram(),
14383 };
14384 defmt::write!(f, "{}", proxy)
14385 }
14386 }
14387 #[doc = "JPEG encoder, AC Huffman table 1"]
14388 #[repr(transparent)]
14389 #[derive(Copy, Clone, Eq, PartialEq)]
14390 pub struct HuffencAc147(pub u32);
14391 impl HuffencAc147 {
14392 #[doc = "DHTMem RAM"]
14393 #[inline(always)]
14394 pub const fn dhtmem_ram(&self) -> u32 {
14395 let val = (self.0 >> 0usize) & 0xffff_ffff;
14396 val as u32
14397 }
14398 #[doc = "DHTMem RAM"]
14399 #[inline(always)]
14400 pub fn set_dhtmem_ram(&mut self, val: u32) {
14401 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14402 }
14403 }
14404 impl Default for HuffencAc147 {
14405 #[inline(always)]
14406 fn default() -> HuffencAc147 {
14407 HuffencAc147(0)
14408 }
14409 }
14410 impl core::fmt::Debug for HuffencAc147 {
14411 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14412 f.debug_struct("HuffencAc147")
14413 .field("dhtmem_ram", &self.dhtmem_ram())
14414 .finish()
14415 }
14416 }
14417 #[cfg(feature = "defmt")]
14418 impl defmt::Format for HuffencAc147 {
14419 fn format(&self, f: defmt::Formatter) {
14420 #[derive(defmt :: Format)]
14421 struct HuffencAc147 {
14422 dhtmem_ram: u32,
14423 }
14424 let proxy = HuffencAc147 {
14425 dhtmem_ram: self.dhtmem_ram(),
14426 };
14427 defmt::write!(f, "{}", proxy)
14428 }
14429 }
14430 #[doc = "JPEG encoder, AC Huffman table 1"]
14431 #[repr(transparent)]
14432 #[derive(Copy, Clone, Eq, PartialEq)]
14433 pub struct HuffencAc148(pub u32);
14434 impl HuffencAc148 {
14435 #[doc = "DHTMem RAM"]
14436 #[inline(always)]
14437 pub const fn dhtmem_ram(&self) -> u32 {
14438 let val = (self.0 >> 0usize) & 0xffff_ffff;
14439 val as u32
14440 }
14441 #[doc = "DHTMem RAM"]
14442 #[inline(always)]
14443 pub fn set_dhtmem_ram(&mut self, val: u32) {
14444 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14445 }
14446 }
14447 impl Default for HuffencAc148 {
14448 #[inline(always)]
14449 fn default() -> HuffencAc148 {
14450 HuffencAc148(0)
14451 }
14452 }
14453 impl core::fmt::Debug for HuffencAc148 {
14454 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14455 f.debug_struct("HuffencAc148")
14456 .field("dhtmem_ram", &self.dhtmem_ram())
14457 .finish()
14458 }
14459 }
14460 #[cfg(feature = "defmt")]
14461 impl defmt::Format for HuffencAc148 {
14462 fn format(&self, f: defmt::Formatter) {
14463 #[derive(defmt :: Format)]
14464 struct HuffencAc148 {
14465 dhtmem_ram: u32,
14466 }
14467 let proxy = HuffencAc148 {
14468 dhtmem_ram: self.dhtmem_ram(),
14469 };
14470 defmt::write!(f, "{}", proxy)
14471 }
14472 }
14473 #[doc = "JPEG encoder, AC Huffman table 1"]
14474 #[repr(transparent)]
14475 #[derive(Copy, Clone, Eq, PartialEq)]
14476 pub struct HuffencAc149(pub u32);
14477 impl HuffencAc149 {
14478 #[doc = "DHTMem RAM"]
14479 #[inline(always)]
14480 pub const fn dhtmem_ram(&self) -> u32 {
14481 let val = (self.0 >> 0usize) & 0xffff_ffff;
14482 val as u32
14483 }
14484 #[doc = "DHTMem RAM"]
14485 #[inline(always)]
14486 pub fn set_dhtmem_ram(&mut self, val: u32) {
14487 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14488 }
14489 }
14490 impl Default for HuffencAc149 {
14491 #[inline(always)]
14492 fn default() -> HuffencAc149 {
14493 HuffencAc149(0)
14494 }
14495 }
14496 impl core::fmt::Debug for HuffencAc149 {
14497 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14498 f.debug_struct("HuffencAc149")
14499 .field("dhtmem_ram", &self.dhtmem_ram())
14500 .finish()
14501 }
14502 }
14503 #[cfg(feature = "defmt")]
14504 impl defmt::Format for HuffencAc149 {
14505 fn format(&self, f: defmt::Formatter) {
14506 #[derive(defmt :: Format)]
14507 struct HuffencAc149 {
14508 dhtmem_ram: u32,
14509 }
14510 let proxy = HuffencAc149 {
14511 dhtmem_ram: self.dhtmem_ram(),
14512 };
14513 defmt::write!(f, "{}", proxy)
14514 }
14515 }
14516 #[doc = "JPEG encoder, AC Huffman table 1"]
14517 #[repr(transparent)]
14518 #[derive(Copy, Clone, Eq, PartialEq)]
14519 pub struct HuffencAc15(pub u32);
14520 impl HuffencAc15 {
14521 #[doc = "DHTMem RAM"]
14522 #[inline(always)]
14523 pub const fn dhtmem_ram(&self) -> u32 {
14524 let val = (self.0 >> 0usize) & 0xffff_ffff;
14525 val as u32
14526 }
14527 #[doc = "DHTMem RAM"]
14528 #[inline(always)]
14529 pub fn set_dhtmem_ram(&mut self, val: u32) {
14530 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14531 }
14532 }
14533 impl Default for HuffencAc15 {
14534 #[inline(always)]
14535 fn default() -> HuffencAc15 {
14536 HuffencAc15(0)
14537 }
14538 }
14539 impl core::fmt::Debug for HuffencAc15 {
14540 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14541 f.debug_struct("HuffencAc15")
14542 .field("dhtmem_ram", &self.dhtmem_ram())
14543 .finish()
14544 }
14545 }
14546 #[cfg(feature = "defmt")]
14547 impl defmt::Format for HuffencAc15 {
14548 fn format(&self, f: defmt::Formatter) {
14549 #[derive(defmt :: Format)]
14550 struct HuffencAc15 {
14551 dhtmem_ram: u32,
14552 }
14553 let proxy = HuffencAc15 {
14554 dhtmem_ram: self.dhtmem_ram(),
14555 };
14556 defmt::write!(f, "{}", proxy)
14557 }
14558 }
14559 #[doc = "JPEG encoder, AC Huffman table 1"]
14560 #[repr(transparent)]
14561 #[derive(Copy, Clone, Eq, PartialEq)]
14562 pub struct HuffencAc150(pub u32);
14563 impl HuffencAc150 {
14564 #[doc = "DHTMem RAM"]
14565 #[inline(always)]
14566 pub const fn dhtmem_ram(&self) -> u32 {
14567 let val = (self.0 >> 0usize) & 0xffff_ffff;
14568 val as u32
14569 }
14570 #[doc = "DHTMem RAM"]
14571 #[inline(always)]
14572 pub fn set_dhtmem_ram(&mut self, val: u32) {
14573 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14574 }
14575 }
14576 impl Default for HuffencAc150 {
14577 #[inline(always)]
14578 fn default() -> HuffencAc150 {
14579 HuffencAc150(0)
14580 }
14581 }
14582 impl core::fmt::Debug for HuffencAc150 {
14583 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14584 f.debug_struct("HuffencAc150")
14585 .field("dhtmem_ram", &self.dhtmem_ram())
14586 .finish()
14587 }
14588 }
14589 #[cfg(feature = "defmt")]
14590 impl defmt::Format for HuffencAc150 {
14591 fn format(&self, f: defmt::Formatter) {
14592 #[derive(defmt :: Format)]
14593 struct HuffencAc150 {
14594 dhtmem_ram: u32,
14595 }
14596 let proxy = HuffencAc150 {
14597 dhtmem_ram: self.dhtmem_ram(),
14598 };
14599 defmt::write!(f, "{}", proxy)
14600 }
14601 }
14602 #[doc = "JPEG encoder, AC Huffman table 1"]
14603 #[repr(transparent)]
14604 #[derive(Copy, Clone, Eq, PartialEq)]
14605 pub struct HuffencAc151(pub u32);
14606 impl HuffencAc151 {
14607 #[doc = "DHTMem RAM"]
14608 #[inline(always)]
14609 pub const fn dhtmem_ram(&self) -> u32 {
14610 let val = (self.0 >> 0usize) & 0xffff_ffff;
14611 val as u32
14612 }
14613 #[doc = "DHTMem RAM"]
14614 #[inline(always)]
14615 pub fn set_dhtmem_ram(&mut self, val: u32) {
14616 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14617 }
14618 }
14619 impl Default for HuffencAc151 {
14620 #[inline(always)]
14621 fn default() -> HuffencAc151 {
14622 HuffencAc151(0)
14623 }
14624 }
14625 impl core::fmt::Debug for HuffencAc151 {
14626 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14627 f.debug_struct("HuffencAc151")
14628 .field("dhtmem_ram", &self.dhtmem_ram())
14629 .finish()
14630 }
14631 }
14632 #[cfg(feature = "defmt")]
14633 impl defmt::Format for HuffencAc151 {
14634 fn format(&self, f: defmt::Formatter) {
14635 #[derive(defmt :: Format)]
14636 struct HuffencAc151 {
14637 dhtmem_ram: u32,
14638 }
14639 let proxy = HuffencAc151 {
14640 dhtmem_ram: self.dhtmem_ram(),
14641 };
14642 defmt::write!(f, "{}", proxy)
14643 }
14644 }
14645 #[doc = "JPEG encoder, AC Huffman table 1"]
14646 #[repr(transparent)]
14647 #[derive(Copy, Clone, Eq, PartialEq)]
14648 pub struct HuffencAc152(pub u32);
14649 impl HuffencAc152 {
14650 #[doc = "DHTMem RAM"]
14651 #[inline(always)]
14652 pub const fn dhtmem_ram(&self) -> u32 {
14653 let val = (self.0 >> 0usize) & 0xffff_ffff;
14654 val as u32
14655 }
14656 #[doc = "DHTMem RAM"]
14657 #[inline(always)]
14658 pub fn set_dhtmem_ram(&mut self, val: u32) {
14659 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14660 }
14661 }
14662 impl Default for HuffencAc152 {
14663 #[inline(always)]
14664 fn default() -> HuffencAc152 {
14665 HuffencAc152(0)
14666 }
14667 }
14668 impl core::fmt::Debug for HuffencAc152 {
14669 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14670 f.debug_struct("HuffencAc152")
14671 .field("dhtmem_ram", &self.dhtmem_ram())
14672 .finish()
14673 }
14674 }
14675 #[cfg(feature = "defmt")]
14676 impl defmt::Format for HuffencAc152 {
14677 fn format(&self, f: defmt::Formatter) {
14678 #[derive(defmt :: Format)]
14679 struct HuffencAc152 {
14680 dhtmem_ram: u32,
14681 }
14682 let proxy = HuffencAc152 {
14683 dhtmem_ram: self.dhtmem_ram(),
14684 };
14685 defmt::write!(f, "{}", proxy)
14686 }
14687 }
14688 #[doc = "JPEG encoder, AC Huffman table 1"]
14689 #[repr(transparent)]
14690 #[derive(Copy, Clone, Eq, PartialEq)]
14691 pub struct HuffencAc153(pub u32);
14692 impl HuffencAc153 {
14693 #[doc = "DHTMem RAM"]
14694 #[inline(always)]
14695 pub const fn dhtmem_ram(&self) -> u32 {
14696 let val = (self.0 >> 0usize) & 0xffff_ffff;
14697 val as u32
14698 }
14699 #[doc = "DHTMem RAM"]
14700 #[inline(always)]
14701 pub fn set_dhtmem_ram(&mut self, val: u32) {
14702 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14703 }
14704 }
14705 impl Default for HuffencAc153 {
14706 #[inline(always)]
14707 fn default() -> HuffencAc153 {
14708 HuffencAc153(0)
14709 }
14710 }
14711 impl core::fmt::Debug for HuffencAc153 {
14712 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14713 f.debug_struct("HuffencAc153")
14714 .field("dhtmem_ram", &self.dhtmem_ram())
14715 .finish()
14716 }
14717 }
14718 #[cfg(feature = "defmt")]
14719 impl defmt::Format for HuffencAc153 {
14720 fn format(&self, f: defmt::Formatter) {
14721 #[derive(defmt :: Format)]
14722 struct HuffencAc153 {
14723 dhtmem_ram: u32,
14724 }
14725 let proxy = HuffencAc153 {
14726 dhtmem_ram: self.dhtmem_ram(),
14727 };
14728 defmt::write!(f, "{}", proxy)
14729 }
14730 }
14731 #[doc = "JPEG encoder, AC Huffman table 1"]
14732 #[repr(transparent)]
14733 #[derive(Copy, Clone, Eq, PartialEq)]
14734 pub struct HuffencAc154(pub u32);
14735 impl HuffencAc154 {
14736 #[doc = "DHTMem RAM"]
14737 #[inline(always)]
14738 pub const fn dhtmem_ram(&self) -> u32 {
14739 let val = (self.0 >> 0usize) & 0xffff_ffff;
14740 val as u32
14741 }
14742 #[doc = "DHTMem RAM"]
14743 #[inline(always)]
14744 pub fn set_dhtmem_ram(&mut self, val: u32) {
14745 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14746 }
14747 }
14748 impl Default for HuffencAc154 {
14749 #[inline(always)]
14750 fn default() -> HuffencAc154 {
14751 HuffencAc154(0)
14752 }
14753 }
14754 impl core::fmt::Debug for HuffencAc154 {
14755 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14756 f.debug_struct("HuffencAc154")
14757 .field("dhtmem_ram", &self.dhtmem_ram())
14758 .finish()
14759 }
14760 }
14761 #[cfg(feature = "defmt")]
14762 impl defmt::Format for HuffencAc154 {
14763 fn format(&self, f: defmt::Formatter) {
14764 #[derive(defmt :: Format)]
14765 struct HuffencAc154 {
14766 dhtmem_ram: u32,
14767 }
14768 let proxy = HuffencAc154 {
14769 dhtmem_ram: self.dhtmem_ram(),
14770 };
14771 defmt::write!(f, "{}", proxy)
14772 }
14773 }
14774 #[doc = "JPEG encoder, AC Huffman table 1"]
14775 #[repr(transparent)]
14776 #[derive(Copy, Clone, Eq, PartialEq)]
14777 pub struct HuffencAc155(pub u32);
14778 impl HuffencAc155 {
14779 #[doc = "DHTMem RAM"]
14780 #[inline(always)]
14781 pub const fn dhtmem_ram(&self) -> u32 {
14782 let val = (self.0 >> 0usize) & 0xffff_ffff;
14783 val as u32
14784 }
14785 #[doc = "DHTMem RAM"]
14786 #[inline(always)]
14787 pub fn set_dhtmem_ram(&mut self, val: u32) {
14788 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14789 }
14790 }
14791 impl Default for HuffencAc155 {
14792 #[inline(always)]
14793 fn default() -> HuffencAc155 {
14794 HuffencAc155(0)
14795 }
14796 }
14797 impl core::fmt::Debug for HuffencAc155 {
14798 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14799 f.debug_struct("HuffencAc155")
14800 .field("dhtmem_ram", &self.dhtmem_ram())
14801 .finish()
14802 }
14803 }
14804 #[cfg(feature = "defmt")]
14805 impl defmt::Format for HuffencAc155 {
14806 fn format(&self, f: defmt::Formatter) {
14807 #[derive(defmt :: Format)]
14808 struct HuffencAc155 {
14809 dhtmem_ram: u32,
14810 }
14811 let proxy = HuffencAc155 {
14812 dhtmem_ram: self.dhtmem_ram(),
14813 };
14814 defmt::write!(f, "{}", proxy)
14815 }
14816 }
14817 #[doc = "JPEG encoder, AC Huffman table 1"]
14818 #[repr(transparent)]
14819 #[derive(Copy, Clone, Eq, PartialEq)]
14820 pub struct HuffencAc156(pub u32);
14821 impl HuffencAc156 {
14822 #[doc = "DHTMem RAM"]
14823 #[inline(always)]
14824 pub const fn dhtmem_ram(&self) -> u32 {
14825 let val = (self.0 >> 0usize) & 0xffff_ffff;
14826 val as u32
14827 }
14828 #[doc = "DHTMem RAM"]
14829 #[inline(always)]
14830 pub fn set_dhtmem_ram(&mut self, val: u32) {
14831 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14832 }
14833 }
14834 impl Default for HuffencAc156 {
14835 #[inline(always)]
14836 fn default() -> HuffencAc156 {
14837 HuffencAc156(0)
14838 }
14839 }
14840 impl core::fmt::Debug for HuffencAc156 {
14841 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14842 f.debug_struct("HuffencAc156")
14843 .field("dhtmem_ram", &self.dhtmem_ram())
14844 .finish()
14845 }
14846 }
14847 #[cfg(feature = "defmt")]
14848 impl defmt::Format for HuffencAc156 {
14849 fn format(&self, f: defmt::Formatter) {
14850 #[derive(defmt :: Format)]
14851 struct HuffencAc156 {
14852 dhtmem_ram: u32,
14853 }
14854 let proxy = HuffencAc156 {
14855 dhtmem_ram: self.dhtmem_ram(),
14856 };
14857 defmt::write!(f, "{}", proxy)
14858 }
14859 }
14860 #[doc = "JPEG encoder, AC Huffman table 1"]
14861 #[repr(transparent)]
14862 #[derive(Copy, Clone, Eq, PartialEq)]
14863 pub struct HuffencAc157(pub u32);
14864 impl HuffencAc157 {
14865 #[doc = "DHTMem RAM"]
14866 #[inline(always)]
14867 pub const fn dhtmem_ram(&self) -> u32 {
14868 let val = (self.0 >> 0usize) & 0xffff_ffff;
14869 val as u32
14870 }
14871 #[doc = "DHTMem RAM"]
14872 #[inline(always)]
14873 pub fn set_dhtmem_ram(&mut self, val: u32) {
14874 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14875 }
14876 }
14877 impl Default for HuffencAc157 {
14878 #[inline(always)]
14879 fn default() -> HuffencAc157 {
14880 HuffencAc157(0)
14881 }
14882 }
14883 impl core::fmt::Debug for HuffencAc157 {
14884 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14885 f.debug_struct("HuffencAc157")
14886 .field("dhtmem_ram", &self.dhtmem_ram())
14887 .finish()
14888 }
14889 }
14890 #[cfg(feature = "defmt")]
14891 impl defmt::Format for HuffencAc157 {
14892 fn format(&self, f: defmt::Formatter) {
14893 #[derive(defmt :: Format)]
14894 struct HuffencAc157 {
14895 dhtmem_ram: u32,
14896 }
14897 let proxy = HuffencAc157 {
14898 dhtmem_ram: self.dhtmem_ram(),
14899 };
14900 defmt::write!(f, "{}", proxy)
14901 }
14902 }
14903 #[doc = "JPEG encoder, AC Huffman table 1"]
14904 #[repr(transparent)]
14905 #[derive(Copy, Clone, Eq, PartialEq)]
14906 pub struct HuffencAc158(pub u32);
14907 impl HuffencAc158 {
14908 #[doc = "DHTMem RAM"]
14909 #[inline(always)]
14910 pub const fn dhtmem_ram(&self) -> u32 {
14911 let val = (self.0 >> 0usize) & 0xffff_ffff;
14912 val as u32
14913 }
14914 #[doc = "DHTMem RAM"]
14915 #[inline(always)]
14916 pub fn set_dhtmem_ram(&mut self, val: u32) {
14917 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14918 }
14919 }
14920 impl Default for HuffencAc158 {
14921 #[inline(always)]
14922 fn default() -> HuffencAc158 {
14923 HuffencAc158(0)
14924 }
14925 }
14926 impl core::fmt::Debug for HuffencAc158 {
14927 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14928 f.debug_struct("HuffencAc158")
14929 .field("dhtmem_ram", &self.dhtmem_ram())
14930 .finish()
14931 }
14932 }
14933 #[cfg(feature = "defmt")]
14934 impl defmt::Format for HuffencAc158 {
14935 fn format(&self, f: defmt::Formatter) {
14936 #[derive(defmt :: Format)]
14937 struct HuffencAc158 {
14938 dhtmem_ram: u32,
14939 }
14940 let proxy = HuffencAc158 {
14941 dhtmem_ram: self.dhtmem_ram(),
14942 };
14943 defmt::write!(f, "{}", proxy)
14944 }
14945 }
14946 #[doc = "JPEG encoder, AC Huffman table 1"]
14947 #[repr(transparent)]
14948 #[derive(Copy, Clone, Eq, PartialEq)]
14949 pub struct HuffencAc159(pub u32);
14950 impl HuffencAc159 {
14951 #[doc = "DHTMem RAM"]
14952 #[inline(always)]
14953 pub const fn dhtmem_ram(&self) -> u32 {
14954 let val = (self.0 >> 0usize) & 0xffff_ffff;
14955 val as u32
14956 }
14957 #[doc = "DHTMem RAM"]
14958 #[inline(always)]
14959 pub fn set_dhtmem_ram(&mut self, val: u32) {
14960 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
14961 }
14962 }
14963 impl Default for HuffencAc159 {
14964 #[inline(always)]
14965 fn default() -> HuffencAc159 {
14966 HuffencAc159(0)
14967 }
14968 }
14969 impl core::fmt::Debug for HuffencAc159 {
14970 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
14971 f.debug_struct("HuffencAc159")
14972 .field("dhtmem_ram", &self.dhtmem_ram())
14973 .finish()
14974 }
14975 }
14976 #[cfg(feature = "defmt")]
14977 impl defmt::Format for HuffencAc159 {
14978 fn format(&self, f: defmt::Formatter) {
14979 #[derive(defmt :: Format)]
14980 struct HuffencAc159 {
14981 dhtmem_ram: u32,
14982 }
14983 let proxy = HuffencAc159 {
14984 dhtmem_ram: self.dhtmem_ram(),
14985 };
14986 defmt::write!(f, "{}", proxy)
14987 }
14988 }
14989 #[doc = "JPEG encoder, AC Huffman table 1"]
14990 #[repr(transparent)]
14991 #[derive(Copy, Clone, Eq, PartialEq)]
14992 pub struct HuffencAc16(pub u32);
14993 impl HuffencAc16 {
14994 #[doc = "DHTMem RAM"]
14995 #[inline(always)]
14996 pub const fn dhtmem_ram(&self) -> u32 {
14997 let val = (self.0 >> 0usize) & 0xffff_ffff;
14998 val as u32
14999 }
15000 #[doc = "DHTMem RAM"]
15001 #[inline(always)]
15002 pub fn set_dhtmem_ram(&mut self, val: u32) {
15003 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15004 }
15005 }
15006 impl Default for HuffencAc16 {
15007 #[inline(always)]
15008 fn default() -> HuffencAc16 {
15009 HuffencAc16(0)
15010 }
15011 }
15012 impl core::fmt::Debug for HuffencAc16 {
15013 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15014 f.debug_struct("HuffencAc16")
15015 .field("dhtmem_ram", &self.dhtmem_ram())
15016 .finish()
15017 }
15018 }
15019 #[cfg(feature = "defmt")]
15020 impl defmt::Format for HuffencAc16 {
15021 fn format(&self, f: defmt::Formatter) {
15022 #[derive(defmt :: Format)]
15023 struct HuffencAc16 {
15024 dhtmem_ram: u32,
15025 }
15026 let proxy = HuffencAc16 {
15027 dhtmem_ram: self.dhtmem_ram(),
15028 };
15029 defmt::write!(f, "{}", proxy)
15030 }
15031 }
15032 #[doc = "JPEG encoder, AC Huffman table 1"]
15033 #[repr(transparent)]
15034 #[derive(Copy, Clone, Eq, PartialEq)]
15035 pub struct HuffencAc160(pub u32);
15036 impl HuffencAc160 {
15037 #[doc = "DHTMem RAM"]
15038 #[inline(always)]
15039 pub const fn dhtmem_ram(&self) -> u32 {
15040 let val = (self.0 >> 0usize) & 0xffff_ffff;
15041 val as u32
15042 }
15043 #[doc = "DHTMem RAM"]
15044 #[inline(always)]
15045 pub fn set_dhtmem_ram(&mut self, val: u32) {
15046 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15047 }
15048 }
15049 impl Default for HuffencAc160 {
15050 #[inline(always)]
15051 fn default() -> HuffencAc160 {
15052 HuffencAc160(0)
15053 }
15054 }
15055 impl core::fmt::Debug for HuffencAc160 {
15056 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15057 f.debug_struct("HuffencAc160")
15058 .field("dhtmem_ram", &self.dhtmem_ram())
15059 .finish()
15060 }
15061 }
15062 #[cfg(feature = "defmt")]
15063 impl defmt::Format for HuffencAc160 {
15064 fn format(&self, f: defmt::Formatter) {
15065 #[derive(defmt :: Format)]
15066 struct HuffencAc160 {
15067 dhtmem_ram: u32,
15068 }
15069 let proxy = HuffencAc160 {
15070 dhtmem_ram: self.dhtmem_ram(),
15071 };
15072 defmt::write!(f, "{}", proxy)
15073 }
15074 }
15075 #[doc = "JPEG encoder, AC Huffman table 1"]
15076 #[repr(transparent)]
15077 #[derive(Copy, Clone, Eq, PartialEq)]
15078 pub struct HuffencAc161(pub u32);
15079 impl HuffencAc161 {
15080 #[doc = "DHTMem RAM"]
15081 #[inline(always)]
15082 pub const fn dhtmem_ram(&self) -> u32 {
15083 let val = (self.0 >> 0usize) & 0xffff_ffff;
15084 val as u32
15085 }
15086 #[doc = "DHTMem RAM"]
15087 #[inline(always)]
15088 pub fn set_dhtmem_ram(&mut self, val: u32) {
15089 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15090 }
15091 }
15092 impl Default for HuffencAc161 {
15093 #[inline(always)]
15094 fn default() -> HuffencAc161 {
15095 HuffencAc161(0)
15096 }
15097 }
15098 impl core::fmt::Debug for HuffencAc161 {
15099 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15100 f.debug_struct("HuffencAc161")
15101 .field("dhtmem_ram", &self.dhtmem_ram())
15102 .finish()
15103 }
15104 }
15105 #[cfg(feature = "defmt")]
15106 impl defmt::Format for HuffencAc161 {
15107 fn format(&self, f: defmt::Formatter) {
15108 #[derive(defmt :: Format)]
15109 struct HuffencAc161 {
15110 dhtmem_ram: u32,
15111 }
15112 let proxy = HuffencAc161 {
15113 dhtmem_ram: self.dhtmem_ram(),
15114 };
15115 defmt::write!(f, "{}", proxy)
15116 }
15117 }
15118 #[doc = "JPEG encoder, AC Huffman table 1"]
15119 #[repr(transparent)]
15120 #[derive(Copy, Clone, Eq, PartialEq)]
15121 pub struct HuffencAc162(pub u32);
15122 impl HuffencAc162 {
15123 #[doc = "DHTMem RAM"]
15124 #[inline(always)]
15125 pub const fn dhtmem_ram(&self) -> u32 {
15126 let val = (self.0 >> 0usize) & 0xffff_ffff;
15127 val as u32
15128 }
15129 #[doc = "DHTMem RAM"]
15130 #[inline(always)]
15131 pub fn set_dhtmem_ram(&mut self, val: u32) {
15132 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15133 }
15134 }
15135 impl Default for HuffencAc162 {
15136 #[inline(always)]
15137 fn default() -> HuffencAc162 {
15138 HuffencAc162(0)
15139 }
15140 }
15141 impl core::fmt::Debug for HuffencAc162 {
15142 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15143 f.debug_struct("HuffencAc162")
15144 .field("dhtmem_ram", &self.dhtmem_ram())
15145 .finish()
15146 }
15147 }
15148 #[cfg(feature = "defmt")]
15149 impl defmt::Format for HuffencAc162 {
15150 fn format(&self, f: defmt::Formatter) {
15151 #[derive(defmt :: Format)]
15152 struct HuffencAc162 {
15153 dhtmem_ram: u32,
15154 }
15155 let proxy = HuffencAc162 {
15156 dhtmem_ram: self.dhtmem_ram(),
15157 };
15158 defmt::write!(f, "{}", proxy)
15159 }
15160 }
15161 #[doc = "JPEG encoder, AC Huffman table 1"]
15162 #[repr(transparent)]
15163 #[derive(Copy, Clone, Eq, PartialEq)]
15164 pub struct HuffencAc163(pub u32);
15165 impl HuffencAc163 {
15166 #[doc = "DHTMem RAM"]
15167 #[inline(always)]
15168 pub const fn dhtmem_ram(&self) -> u32 {
15169 let val = (self.0 >> 0usize) & 0xffff_ffff;
15170 val as u32
15171 }
15172 #[doc = "DHTMem RAM"]
15173 #[inline(always)]
15174 pub fn set_dhtmem_ram(&mut self, val: u32) {
15175 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15176 }
15177 }
15178 impl Default for HuffencAc163 {
15179 #[inline(always)]
15180 fn default() -> HuffencAc163 {
15181 HuffencAc163(0)
15182 }
15183 }
15184 impl core::fmt::Debug for HuffencAc163 {
15185 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15186 f.debug_struct("HuffencAc163")
15187 .field("dhtmem_ram", &self.dhtmem_ram())
15188 .finish()
15189 }
15190 }
15191 #[cfg(feature = "defmt")]
15192 impl defmt::Format for HuffencAc163 {
15193 fn format(&self, f: defmt::Formatter) {
15194 #[derive(defmt :: Format)]
15195 struct HuffencAc163 {
15196 dhtmem_ram: u32,
15197 }
15198 let proxy = HuffencAc163 {
15199 dhtmem_ram: self.dhtmem_ram(),
15200 };
15201 defmt::write!(f, "{}", proxy)
15202 }
15203 }
15204 #[doc = "JPEG encoder, AC Huffman table 1"]
15205 #[repr(transparent)]
15206 #[derive(Copy, Clone, Eq, PartialEq)]
15207 pub struct HuffencAc164(pub u32);
15208 impl HuffencAc164 {
15209 #[doc = "DHTMem RAM"]
15210 #[inline(always)]
15211 pub const fn dhtmem_ram(&self) -> u32 {
15212 let val = (self.0 >> 0usize) & 0xffff_ffff;
15213 val as u32
15214 }
15215 #[doc = "DHTMem RAM"]
15216 #[inline(always)]
15217 pub fn set_dhtmem_ram(&mut self, val: u32) {
15218 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15219 }
15220 }
15221 impl Default for HuffencAc164 {
15222 #[inline(always)]
15223 fn default() -> HuffencAc164 {
15224 HuffencAc164(0)
15225 }
15226 }
15227 impl core::fmt::Debug for HuffencAc164 {
15228 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15229 f.debug_struct("HuffencAc164")
15230 .field("dhtmem_ram", &self.dhtmem_ram())
15231 .finish()
15232 }
15233 }
15234 #[cfg(feature = "defmt")]
15235 impl defmt::Format for HuffencAc164 {
15236 fn format(&self, f: defmt::Formatter) {
15237 #[derive(defmt :: Format)]
15238 struct HuffencAc164 {
15239 dhtmem_ram: u32,
15240 }
15241 let proxy = HuffencAc164 {
15242 dhtmem_ram: self.dhtmem_ram(),
15243 };
15244 defmt::write!(f, "{}", proxy)
15245 }
15246 }
15247 #[doc = "JPEG encoder, AC Huffman table 1"]
15248 #[repr(transparent)]
15249 #[derive(Copy, Clone, Eq, PartialEq)]
15250 pub struct HuffencAc165(pub u32);
15251 impl HuffencAc165 {
15252 #[doc = "DHTMem RAM"]
15253 #[inline(always)]
15254 pub const fn dhtmem_ram(&self) -> u32 {
15255 let val = (self.0 >> 0usize) & 0xffff_ffff;
15256 val as u32
15257 }
15258 #[doc = "DHTMem RAM"]
15259 #[inline(always)]
15260 pub fn set_dhtmem_ram(&mut self, val: u32) {
15261 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15262 }
15263 }
15264 impl Default for HuffencAc165 {
15265 #[inline(always)]
15266 fn default() -> HuffencAc165 {
15267 HuffencAc165(0)
15268 }
15269 }
15270 impl core::fmt::Debug for HuffencAc165 {
15271 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15272 f.debug_struct("HuffencAc165")
15273 .field("dhtmem_ram", &self.dhtmem_ram())
15274 .finish()
15275 }
15276 }
15277 #[cfg(feature = "defmt")]
15278 impl defmt::Format for HuffencAc165 {
15279 fn format(&self, f: defmt::Formatter) {
15280 #[derive(defmt :: Format)]
15281 struct HuffencAc165 {
15282 dhtmem_ram: u32,
15283 }
15284 let proxy = HuffencAc165 {
15285 dhtmem_ram: self.dhtmem_ram(),
15286 };
15287 defmt::write!(f, "{}", proxy)
15288 }
15289 }
15290 #[doc = "JPEG encoder, AC Huffman table 1"]
15291 #[repr(transparent)]
15292 #[derive(Copy, Clone, Eq, PartialEq)]
15293 pub struct HuffencAc166(pub u32);
15294 impl HuffencAc166 {
15295 #[doc = "DHTMem RAM"]
15296 #[inline(always)]
15297 pub const fn dhtmem_ram(&self) -> u32 {
15298 let val = (self.0 >> 0usize) & 0xffff_ffff;
15299 val as u32
15300 }
15301 #[doc = "DHTMem RAM"]
15302 #[inline(always)]
15303 pub fn set_dhtmem_ram(&mut self, val: u32) {
15304 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15305 }
15306 }
15307 impl Default for HuffencAc166 {
15308 #[inline(always)]
15309 fn default() -> HuffencAc166 {
15310 HuffencAc166(0)
15311 }
15312 }
15313 impl core::fmt::Debug for HuffencAc166 {
15314 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15315 f.debug_struct("HuffencAc166")
15316 .field("dhtmem_ram", &self.dhtmem_ram())
15317 .finish()
15318 }
15319 }
15320 #[cfg(feature = "defmt")]
15321 impl defmt::Format for HuffencAc166 {
15322 fn format(&self, f: defmt::Formatter) {
15323 #[derive(defmt :: Format)]
15324 struct HuffencAc166 {
15325 dhtmem_ram: u32,
15326 }
15327 let proxy = HuffencAc166 {
15328 dhtmem_ram: self.dhtmem_ram(),
15329 };
15330 defmt::write!(f, "{}", proxy)
15331 }
15332 }
15333 #[doc = "JPEG encoder, AC Huffman table 1"]
15334 #[repr(transparent)]
15335 #[derive(Copy, Clone, Eq, PartialEq)]
15336 pub struct HuffencAc167(pub u32);
15337 impl HuffencAc167 {
15338 #[doc = "DHTMem RAM"]
15339 #[inline(always)]
15340 pub const fn dhtmem_ram(&self) -> u32 {
15341 let val = (self.0 >> 0usize) & 0xffff_ffff;
15342 val as u32
15343 }
15344 #[doc = "DHTMem RAM"]
15345 #[inline(always)]
15346 pub fn set_dhtmem_ram(&mut self, val: u32) {
15347 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15348 }
15349 }
15350 impl Default for HuffencAc167 {
15351 #[inline(always)]
15352 fn default() -> HuffencAc167 {
15353 HuffencAc167(0)
15354 }
15355 }
15356 impl core::fmt::Debug for HuffencAc167 {
15357 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15358 f.debug_struct("HuffencAc167")
15359 .field("dhtmem_ram", &self.dhtmem_ram())
15360 .finish()
15361 }
15362 }
15363 #[cfg(feature = "defmt")]
15364 impl defmt::Format for HuffencAc167 {
15365 fn format(&self, f: defmt::Formatter) {
15366 #[derive(defmt :: Format)]
15367 struct HuffencAc167 {
15368 dhtmem_ram: u32,
15369 }
15370 let proxy = HuffencAc167 {
15371 dhtmem_ram: self.dhtmem_ram(),
15372 };
15373 defmt::write!(f, "{}", proxy)
15374 }
15375 }
15376 #[doc = "JPEG encoder, AC Huffman table 1"]
15377 #[repr(transparent)]
15378 #[derive(Copy, Clone, Eq, PartialEq)]
15379 pub struct HuffencAc168(pub u32);
15380 impl HuffencAc168 {
15381 #[doc = "DHTMem RAM"]
15382 #[inline(always)]
15383 pub const fn dhtmem_ram(&self) -> u32 {
15384 let val = (self.0 >> 0usize) & 0xffff_ffff;
15385 val as u32
15386 }
15387 #[doc = "DHTMem RAM"]
15388 #[inline(always)]
15389 pub fn set_dhtmem_ram(&mut self, val: u32) {
15390 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15391 }
15392 }
15393 impl Default for HuffencAc168 {
15394 #[inline(always)]
15395 fn default() -> HuffencAc168 {
15396 HuffencAc168(0)
15397 }
15398 }
15399 impl core::fmt::Debug for HuffencAc168 {
15400 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15401 f.debug_struct("HuffencAc168")
15402 .field("dhtmem_ram", &self.dhtmem_ram())
15403 .finish()
15404 }
15405 }
15406 #[cfg(feature = "defmt")]
15407 impl defmt::Format for HuffencAc168 {
15408 fn format(&self, f: defmt::Formatter) {
15409 #[derive(defmt :: Format)]
15410 struct HuffencAc168 {
15411 dhtmem_ram: u32,
15412 }
15413 let proxy = HuffencAc168 {
15414 dhtmem_ram: self.dhtmem_ram(),
15415 };
15416 defmt::write!(f, "{}", proxy)
15417 }
15418 }
15419 #[doc = "JPEG encoder, AC Huffman table 1"]
15420 #[repr(transparent)]
15421 #[derive(Copy, Clone, Eq, PartialEq)]
15422 pub struct HuffencAc169(pub u32);
15423 impl HuffencAc169 {
15424 #[doc = "DHTMem RAM"]
15425 #[inline(always)]
15426 pub const fn dhtmem_ram(&self) -> u32 {
15427 let val = (self.0 >> 0usize) & 0xffff_ffff;
15428 val as u32
15429 }
15430 #[doc = "DHTMem RAM"]
15431 #[inline(always)]
15432 pub fn set_dhtmem_ram(&mut self, val: u32) {
15433 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15434 }
15435 }
15436 impl Default for HuffencAc169 {
15437 #[inline(always)]
15438 fn default() -> HuffencAc169 {
15439 HuffencAc169(0)
15440 }
15441 }
15442 impl core::fmt::Debug for HuffencAc169 {
15443 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15444 f.debug_struct("HuffencAc169")
15445 .field("dhtmem_ram", &self.dhtmem_ram())
15446 .finish()
15447 }
15448 }
15449 #[cfg(feature = "defmt")]
15450 impl defmt::Format for HuffencAc169 {
15451 fn format(&self, f: defmt::Formatter) {
15452 #[derive(defmt :: Format)]
15453 struct HuffencAc169 {
15454 dhtmem_ram: u32,
15455 }
15456 let proxy = HuffencAc169 {
15457 dhtmem_ram: self.dhtmem_ram(),
15458 };
15459 defmt::write!(f, "{}", proxy)
15460 }
15461 }
15462 #[doc = "JPEG encoder, AC Huffman table 1"]
15463 #[repr(transparent)]
15464 #[derive(Copy, Clone, Eq, PartialEq)]
15465 pub struct HuffencAc17(pub u32);
15466 impl HuffencAc17 {
15467 #[doc = "DHTMem RAM"]
15468 #[inline(always)]
15469 pub const fn dhtmem_ram(&self) -> u32 {
15470 let val = (self.0 >> 0usize) & 0xffff_ffff;
15471 val as u32
15472 }
15473 #[doc = "DHTMem RAM"]
15474 #[inline(always)]
15475 pub fn set_dhtmem_ram(&mut self, val: u32) {
15476 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15477 }
15478 }
15479 impl Default for HuffencAc17 {
15480 #[inline(always)]
15481 fn default() -> HuffencAc17 {
15482 HuffencAc17(0)
15483 }
15484 }
15485 impl core::fmt::Debug for HuffencAc17 {
15486 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15487 f.debug_struct("HuffencAc17")
15488 .field("dhtmem_ram", &self.dhtmem_ram())
15489 .finish()
15490 }
15491 }
15492 #[cfg(feature = "defmt")]
15493 impl defmt::Format for HuffencAc17 {
15494 fn format(&self, f: defmt::Formatter) {
15495 #[derive(defmt :: Format)]
15496 struct HuffencAc17 {
15497 dhtmem_ram: u32,
15498 }
15499 let proxy = HuffencAc17 {
15500 dhtmem_ram: self.dhtmem_ram(),
15501 };
15502 defmt::write!(f, "{}", proxy)
15503 }
15504 }
15505 #[doc = "JPEG encoder, AC Huffman table 1"]
15506 #[repr(transparent)]
15507 #[derive(Copy, Clone, Eq, PartialEq)]
15508 pub struct HuffencAc170(pub u32);
15509 impl HuffencAc170 {
15510 #[doc = "DHTMem RAM"]
15511 #[inline(always)]
15512 pub const fn dhtmem_ram(&self) -> u32 {
15513 let val = (self.0 >> 0usize) & 0xffff_ffff;
15514 val as u32
15515 }
15516 #[doc = "DHTMem RAM"]
15517 #[inline(always)]
15518 pub fn set_dhtmem_ram(&mut self, val: u32) {
15519 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15520 }
15521 }
15522 impl Default for HuffencAc170 {
15523 #[inline(always)]
15524 fn default() -> HuffencAc170 {
15525 HuffencAc170(0)
15526 }
15527 }
15528 impl core::fmt::Debug for HuffencAc170 {
15529 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15530 f.debug_struct("HuffencAc170")
15531 .field("dhtmem_ram", &self.dhtmem_ram())
15532 .finish()
15533 }
15534 }
15535 #[cfg(feature = "defmt")]
15536 impl defmt::Format for HuffencAc170 {
15537 fn format(&self, f: defmt::Formatter) {
15538 #[derive(defmt :: Format)]
15539 struct HuffencAc170 {
15540 dhtmem_ram: u32,
15541 }
15542 let proxy = HuffencAc170 {
15543 dhtmem_ram: self.dhtmem_ram(),
15544 };
15545 defmt::write!(f, "{}", proxy)
15546 }
15547 }
15548 #[doc = "JPEG encoder, AC Huffman table 1"]
15549 #[repr(transparent)]
15550 #[derive(Copy, Clone, Eq, PartialEq)]
15551 pub struct HuffencAc171(pub u32);
15552 impl HuffencAc171 {
15553 #[doc = "DHTMem RAM"]
15554 #[inline(always)]
15555 pub const fn dhtmem_ram(&self) -> u32 {
15556 let val = (self.0 >> 0usize) & 0xffff_ffff;
15557 val as u32
15558 }
15559 #[doc = "DHTMem RAM"]
15560 #[inline(always)]
15561 pub fn set_dhtmem_ram(&mut self, val: u32) {
15562 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15563 }
15564 }
15565 impl Default for HuffencAc171 {
15566 #[inline(always)]
15567 fn default() -> HuffencAc171 {
15568 HuffencAc171(0)
15569 }
15570 }
15571 impl core::fmt::Debug for HuffencAc171 {
15572 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15573 f.debug_struct("HuffencAc171")
15574 .field("dhtmem_ram", &self.dhtmem_ram())
15575 .finish()
15576 }
15577 }
15578 #[cfg(feature = "defmt")]
15579 impl defmt::Format for HuffencAc171 {
15580 fn format(&self, f: defmt::Formatter) {
15581 #[derive(defmt :: Format)]
15582 struct HuffencAc171 {
15583 dhtmem_ram: u32,
15584 }
15585 let proxy = HuffencAc171 {
15586 dhtmem_ram: self.dhtmem_ram(),
15587 };
15588 defmt::write!(f, "{}", proxy)
15589 }
15590 }
15591 #[doc = "JPEG encoder, AC Huffman table 1"]
15592 #[repr(transparent)]
15593 #[derive(Copy, Clone, Eq, PartialEq)]
15594 pub struct HuffencAc172(pub u32);
15595 impl HuffencAc172 {
15596 #[doc = "DHTMem RAM"]
15597 #[inline(always)]
15598 pub const fn dhtmem_ram(&self) -> u32 {
15599 let val = (self.0 >> 0usize) & 0xffff_ffff;
15600 val as u32
15601 }
15602 #[doc = "DHTMem RAM"]
15603 #[inline(always)]
15604 pub fn set_dhtmem_ram(&mut self, val: u32) {
15605 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15606 }
15607 }
15608 impl Default for HuffencAc172 {
15609 #[inline(always)]
15610 fn default() -> HuffencAc172 {
15611 HuffencAc172(0)
15612 }
15613 }
15614 impl core::fmt::Debug for HuffencAc172 {
15615 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15616 f.debug_struct("HuffencAc172")
15617 .field("dhtmem_ram", &self.dhtmem_ram())
15618 .finish()
15619 }
15620 }
15621 #[cfg(feature = "defmt")]
15622 impl defmt::Format for HuffencAc172 {
15623 fn format(&self, f: defmt::Formatter) {
15624 #[derive(defmt :: Format)]
15625 struct HuffencAc172 {
15626 dhtmem_ram: u32,
15627 }
15628 let proxy = HuffencAc172 {
15629 dhtmem_ram: self.dhtmem_ram(),
15630 };
15631 defmt::write!(f, "{}", proxy)
15632 }
15633 }
15634 #[doc = "JPEG encoder, AC Huffman table 1"]
15635 #[repr(transparent)]
15636 #[derive(Copy, Clone, Eq, PartialEq)]
15637 pub struct HuffencAc173(pub u32);
15638 impl HuffencAc173 {
15639 #[doc = "DHTMem RAM"]
15640 #[inline(always)]
15641 pub const fn dhtmem_ram(&self) -> u32 {
15642 let val = (self.0 >> 0usize) & 0xffff_ffff;
15643 val as u32
15644 }
15645 #[doc = "DHTMem RAM"]
15646 #[inline(always)]
15647 pub fn set_dhtmem_ram(&mut self, val: u32) {
15648 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15649 }
15650 }
15651 impl Default for HuffencAc173 {
15652 #[inline(always)]
15653 fn default() -> HuffencAc173 {
15654 HuffencAc173(0)
15655 }
15656 }
15657 impl core::fmt::Debug for HuffencAc173 {
15658 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15659 f.debug_struct("HuffencAc173")
15660 .field("dhtmem_ram", &self.dhtmem_ram())
15661 .finish()
15662 }
15663 }
15664 #[cfg(feature = "defmt")]
15665 impl defmt::Format for HuffencAc173 {
15666 fn format(&self, f: defmt::Formatter) {
15667 #[derive(defmt :: Format)]
15668 struct HuffencAc173 {
15669 dhtmem_ram: u32,
15670 }
15671 let proxy = HuffencAc173 {
15672 dhtmem_ram: self.dhtmem_ram(),
15673 };
15674 defmt::write!(f, "{}", proxy)
15675 }
15676 }
15677 #[doc = "JPEG encoder, AC Huffman table 1"]
15678 #[repr(transparent)]
15679 #[derive(Copy, Clone, Eq, PartialEq)]
15680 pub struct HuffencAc174(pub u32);
15681 impl HuffencAc174 {
15682 #[doc = "DHTMem RAM"]
15683 #[inline(always)]
15684 pub const fn dhtmem_ram(&self) -> u32 {
15685 let val = (self.0 >> 0usize) & 0xffff_ffff;
15686 val as u32
15687 }
15688 #[doc = "DHTMem RAM"]
15689 #[inline(always)]
15690 pub fn set_dhtmem_ram(&mut self, val: u32) {
15691 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15692 }
15693 }
15694 impl Default for HuffencAc174 {
15695 #[inline(always)]
15696 fn default() -> HuffencAc174 {
15697 HuffencAc174(0)
15698 }
15699 }
15700 impl core::fmt::Debug for HuffencAc174 {
15701 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15702 f.debug_struct("HuffencAc174")
15703 .field("dhtmem_ram", &self.dhtmem_ram())
15704 .finish()
15705 }
15706 }
15707 #[cfg(feature = "defmt")]
15708 impl defmt::Format for HuffencAc174 {
15709 fn format(&self, f: defmt::Formatter) {
15710 #[derive(defmt :: Format)]
15711 struct HuffencAc174 {
15712 dhtmem_ram: u32,
15713 }
15714 let proxy = HuffencAc174 {
15715 dhtmem_ram: self.dhtmem_ram(),
15716 };
15717 defmt::write!(f, "{}", proxy)
15718 }
15719 }
15720 #[doc = "JPEG encoder, AC Huffman table 1"]
15721 #[repr(transparent)]
15722 #[derive(Copy, Clone, Eq, PartialEq)]
15723 pub struct HuffencAc175(pub u32);
15724 impl HuffencAc175 {
15725 #[doc = "DHTMem RAM"]
15726 #[inline(always)]
15727 pub const fn dhtmem_ram(&self) -> u32 {
15728 let val = (self.0 >> 0usize) & 0xffff_ffff;
15729 val as u32
15730 }
15731 #[doc = "DHTMem RAM"]
15732 #[inline(always)]
15733 pub fn set_dhtmem_ram(&mut self, val: u32) {
15734 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15735 }
15736 }
15737 impl Default for HuffencAc175 {
15738 #[inline(always)]
15739 fn default() -> HuffencAc175 {
15740 HuffencAc175(0)
15741 }
15742 }
15743 impl core::fmt::Debug for HuffencAc175 {
15744 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15745 f.debug_struct("HuffencAc175")
15746 .field("dhtmem_ram", &self.dhtmem_ram())
15747 .finish()
15748 }
15749 }
15750 #[cfg(feature = "defmt")]
15751 impl defmt::Format for HuffencAc175 {
15752 fn format(&self, f: defmt::Formatter) {
15753 #[derive(defmt :: Format)]
15754 struct HuffencAc175 {
15755 dhtmem_ram: u32,
15756 }
15757 let proxy = HuffencAc175 {
15758 dhtmem_ram: self.dhtmem_ram(),
15759 };
15760 defmt::write!(f, "{}", proxy)
15761 }
15762 }
15763 #[doc = "JPEG encoder, AC Huffman table 1"]
15764 #[repr(transparent)]
15765 #[derive(Copy, Clone, Eq, PartialEq)]
15766 pub struct HuffencAc176(pub u32);
15767 impl HuffencAc176 {
15768 #[doc = "DHTMem RAM"]
15769 #[inline(always)]
15770 pub const fn dhtmem_ram(&self) -> u32 {
15771 let val = (self.0 >> 0usize) & 0xffff_ffff;
15772 val as u32
15773 }
15774 #[doc = "DHTMem RAM"]
15775 #[inline(always)]
15776 pub fn set_dhtmem_ram(&mut self, val: u32) {
15777 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15778 }
15779 }
15780 impl Default for HuffencAc176 {
15781 #[inline(always)]
15782 fn default() -> HuffencAc176 {
15783 HuffencAc176(0)
15784 }
15785 }
15786 impl core::fmt::Debug for HuffencAc176 {
15787 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15788 f.debug_struct("HuffencAc176")
15789 .field("dhtmem_ram", &self.dhtmem_ram())
15790 .finish()
15791 }
15792 }
15793 #[cfg(feature = "defmt")]
15794 impl defmt::Format for HuffencAc176 {
15795 fn format(&self, f: defmt::Formatter) {
15796 #[derive(defmt :: Format)]
15797 struct HuffencAc176 {
15798 dhtmem_ram: u32,
15799 }
15800 let proxy = HuffencAc176 {
15801 dhtmem_ram: self.dhtmem_ram(),
15802 };
15803 defmt::write!(f, "{}", proxy)
15804 }
15805 }
15806 #[doc = "JPEG encoder, AC Huffman table 1"]
15807 #[repr(transparent)]
15808 #[derive(Copy, Clone, Eq, PartialEq)]
15809 pub struct HuffencAc177(pub u32);
15810 impl HuffencAc177 {
15811 #[doc = "DHTMem RAM"]
15812 #[inline(always)]
15813 pub const fn dhtmem_ram(&self) -> u32 {
15814 let val = (self.0 >> 0usize) & 0xffff_ffff;
15815 val as u32
15816 }
15817 #[doc = "DHTMem RAM"]
15818 #[inline(always)]
15819 pub fn set_dhtmem_ram(&mut self, val: u32) {
15820 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15821 }
15822 }
15823 impl Default for HuffencAc177 {
15824 #[inline(always)]
15825 fn default() -> HuffencAc177 {
15826 HuffencAc177(0)
15827 }
15828 }
15829 impl core::fmt::Debug for HuffencAc177 {
15830 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15831 f.debug_struct("HuffencAc177")
15832 .field("dhtmem_ram", &self.dhtmem_ram())
15833 .finish()
15834 }
15835 }
15836 #[cfg(feature = "defmt")]
15837 impl defmt::Format for HuffencAc177 {
15838 fn format(&self, f: defmt::Formatter) {
15839 #[derive(defmt :: Format)]
15840 struct HuffencAc177 {
15841 dhtmem_ram: u32,
15842 }
15843 let proxy = HuffencAc177 {
15844 dhtmem_ram: self.dhtmem_ram(),
15845 };
15846 defmt::write!(f, "{}", proxy)
15847 }
15848 }
15849 #[doc = "JPEG encoder, AC Huffman table 1"]
15850 #[repr(transparent)]
15851 #[derive(Copy, Clone, Eq, PartialEq)]
15852 pub struct HuffencAc178(pub u32);
15853 impl HuffencAc178 {
15854 #[doc = "DHTMem RAM"]
15855 #[inline(always)]
15856 pub const fn dhtmem_ram(&self) -> u32 {
15857 let val = (self.0 >> 0usize) & 0xffff_ffff;
15858 val as u32
15859 }
15860 #[doc = "DHTMem RAM"]
15861 #[inline(always)]
15862 pub fn set_dhtmem_ram(&mut self, val: u32) {
15863 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15864 }
15865 }
15866 impl Default for HuffencAc178 {
15867 #[inline(always)]
15868 fn default() -> HuffencAc178 {
15869 HuffencAc178(0)
15870 }
15871 }
15872 impl core::fmt::Debug for HuffencAc178 {
15873 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15874 f.debug_struct("HuffencAc178")
15875 .field("dhtmem_ram", &self.dhtmem_ram())
15876 .finish()
15877 }
15878 }
15879 #[cfg(feature = "defmt")]
15880 impl defmt::Format for HuffencAc178 {
15881 fn format(&self, f: defmt::Formatter) {
15882 #[derive(defmt :: Format)]
15883 struct HuffencAc178 {
15884 dhtmem_ram: u32,
15885 }
15886 let proxy = HuffencAc178 {
15887 dhtmem_ram: self.dhtmem_ram(),
15888 };
15889 defmt::write!(f, "{}", proxy)
15890 }
15891 }
15892 #[doc = "JPEG encoder, AC Huffman table 1"]
15893 #[repr(transparent)]
15894 #[derive(Copy, Clone, Eq, PartialEq)]
15895 pub struct HuffencAc179(pub u32);
15896 impl HuffencAc179 {
15897 #[doc = "DHTMem RAM"]
15898 #[inline(always)]
15899 pub const fn dhtmem_ram(&self) -> u32 {
15900 let val = (self.0 >> 0usize) & 0xffff_ffff;
15901 val as u32
15902 }
15903 #[doc = "DHTMem RAM"]
15904 #[inline(always)]
15905 pub fn set_dhtmem_ram(&mut self, val: u32) {
15906 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15907 }
15908 }
15909 impl Default for HuffencAc179 {
15910 #[inline(always)]
15911 fn default() -> HuffencAc179 {
15912 HuffencAc179(0)
15913 }
15914 }
15915 impl core::fmt::Debug for HuffencAc179 {
15916 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15917 f.debug_struct("HuffencAc179")
15918 .field("dhtmem_ram", &self.dhtmem_ram())
15919 .finish()
15920 }
15921 }
15922 #[cfg(feature = "defmt")]
15923 impl defmt::Format for HuffencAc179 {
15924 fn format(&self, f: defmt::Formatter) {
15925 #[derive(defmt :: Format)]
15926 struct HuffencAc179 {
15927 dhtmem_ram: u32,
15928 }
15929 let proxy = HuffencAc179 {
15930 dhtmem_ram: self.dhtmem_ram(),
15931 };
15932 defmt::write!(f, "{}", proxy)
15933 }
15934 }
15935 #[doc = "JPEG encoder, AC Huffman table 1"]
15936 #[repr(transparent)]
15937 #[derive(Copy, Clone, Eq, PartialEq)]
15938 pub struct HuffencAc18(pub u32);
15939 impl HuffencAc18 {
15940 #[doc = "DHTMem RAM"]
15941 #[inline(always)]
15942 pub const fn dhtmem_ram(&self) -> u32 {
15943 let val = (self.0 >> 0usize) & 0xffff_ffff;
15944 val as u32
15945 }
15946 #[doc = "DHTMem RAM"]
15947 #[inline(always)]
15948 pub fn set_dhtmem_ram(&mut self, val: u32) {
15949 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15950 }
15951 }
15952 impl Default for HuffencAc18 {
15953 #[inline(always)]
15954 fn default() -> HuffencAc18 {
15955 HuffencAc18(0)
15956 }
15957 }
15958 impl core::fmt::Debug for HuffencAc18 {
15959 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
15960 f.debug_struct("HuffencAc18")
15961 .field("dhtmem_ram", &self.dhtmem_ram())
15962 .finish()
15963 }
15964 }
15965 #[cfg(feature = "defmt")]
15966 impl defmt::Format for HuffencAc18 {
15967 fn format(&self, f: defmt::Formatter) {
15968 #[derive(defmt :: Format)]
15969 struct HuffencAc18 {
15970 dhtmem_ram: u32,
15971 }
15972 let proxy = HuffencAc18 {
15973 dhtmem_ram: self.dhtmem_ram(),
15974 };
15975 defmt::write!(f, "{}", proxy)
15976 }
15977 }
15978 #[doc = "JPEG encoder, AC Huffman table 1"]
15979 #[repr(transparent)]
15980 #[derive(Copy, Clone, Eq, PartialEq)]
15981 pub struct HuffencAc180(pub u32);
15982 impl HuffencAc180 {
15983 #[doc = "DHTMem RAM"]
15984 #[inline(always)]
15985 pub const fn dhtmem_ram(&self) -> u32 {
15986 let val = (self.0 >> 0usize) & 0xffff_ffff;
15987 val as u32
15988 }
15989 #[doc = "DHTMem RAM"]
15990 #[inline(always)]
15991 pub fn set_dhtmem_ram(&mut self, val: u32) {
15992 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
15993 }
15994 }
15995 impl Default for HuffencAc180 {
15996 #[inline(always)]
15997 fn default() -> HuffencAc180 {
15998 HuffencAc180(0)
15999 }
16000 }
16001 impl core::fmt::Debug for HuffencAc180 {
16002 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16003 f.debug_struct("HuffencAc180")
16004 .field("dhtmem_ram", &self.dhtmem_ram())
16005 .finish()
16006 }
16007 }
16008 #[cfg(feature = "defmt")]
16009 impl defmt::Format for HuffencAc180 {
16010 fn format(&self, f: defmt::Formatter) {
16011 #[derive(defmt :: Format)]
16012 struct HuffencAc180 {
16013 dhtmem_ram: u32,
16014 }
16015 let proxy = HuffencAc180 {
16016 dhtmem_ram: self.dhtmem_ram(),
16017 };
16018 defmt::write!(f, "{}", proxy)
16019 }
16020 }
16021 #[doc = "JPEG encoder, AC Huffman table 1"]
16022 #[repr(transparent)]
16023 #[derive(Copy, Clone, Eq, PartialEq)]
16024 pub struct HuffencAc181(pub u32);
16025 impl HuffencAc181 {
16026 #[doc = "DHTMem RAM"]
16027 #[inline(always)]
16028 pub const fn dhtmem_ram(&self) -> u32 {
16029 let val = (self.0 >> 0usize) & 0xffff_ffff;
16030 val as u32
16031 }
16032 #[doc = "DHTMem RAM"]
16033 #[inline(always)]
16034 pub fn set_dhtmem_ram(&mut self, val: u32) {
16035 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16036 }
16037 }
16038 impl Default for HuffencAc181 {
16039 #[inline(always)]
16040 fn default() -> HuffencAc181 {
16041 HuffencAc181(0)
16042 }
16043 }
16044 impl core::fmt::Debug for HuffencAc181 {
16045 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16046 f.debug_struct("HuffencAc181")
16047 .field("dhtmem_ram", &self.dhtmem_ram())
16048 .finish()
16049 }
16050 }
16051 #[cfg(feature = "defmt")]
16052 impl defmt::Format for HuffencAc181 {
16053 fn format(&self, f: defmt::Formatter) {
16054 #[derive(defmt :: Format)]
16055 struct HuffencAc181 {
16056 dhtmem_ram: u32,
16057 }
16058 let proxy = HuffencAc181 {
16059 dhtmem_ram: self.dhtmem_ram(),
16060 };
16061 defmt::write!(f, "{}", proxy)
16062 }
16063 }
16064 #[doc = "JPEG encoder, AC Huffman table 1"]
16065 #[repr(transparent)]
16066 #[derive(Copy, Clone, Eq, PartialEq)]
16067 pub struct HuffencAc182(pub u32);
16068 impl HuffencAc182 {
16069 #[doc = "DHTMem RAM"]
16070 #[inline(always)]
16071 pub const fn dhtmem_ram(&self) -> u32 {
16072 let val = (self.0 >> 0usize) & 0xffff_ffff;
16073 val as u32
16074 }
16075 #[doc = "DHTMem RAM"]
16076 #[inline(always)]
16077 pub fn set_dhtmem_ram(&mut self, val: u32) {
16078 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16079 }
16080 }
16081 impl Default for HuffencAc182 {
16082 #[inline(always)]
16083 fn default() -> HuffencAc182 {
16084 HuffencAc182(0)
16085 }
16086 }
16087 impl core::fmt::Debug for HuffencAc182 {
16088 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16089 f.debug_struct("HuffencAc182")
16090 .field("dhtmem_ram", &self.dhtmem_ram())
16091 .finish()
16092 }
16093 }
16094 #[cfg(feature = "defmt")]
16095 impl defmt::Format for HuffencAc182 {
16096 fn format(&self, f: defmt::Formatter) {
16097 #[derive(defmt :: Format)]
16098 struct HuffencAc182 {
16099 dhtmem_ram: u32,
16100 }
16101 let proxy = HuffencAc182 {
16102 dhtmem_ram: self.dhtmem_ram(),
16103 };
16104 defmt::write!(f, "{}", proxy)
16105 }
16106 }
16107 #[doc = "JPEG encoder, AC Huffman table 1"]
16108 #[repr(transparent)]
16109 #[derive(Copy, Clone, Eq, PartialEq)]
16110 pub struct HuffencAc183(pub u32);
16111 impl HuffencAc183 {
16112 #[doc = "DHTMem RAM"]
16113 #[inline(always)]
16114 pub const fn dhtmem_ram(&self) -> u32 {
16115 let val = (self.0 >> 0usize) & 0xffff_ffff;
16116 val as u32
16117 }
16118 #[doc = "DHTMem RAM"]
16119 #[inline(always)]
16120 pub fn set_dhtmem_ram(&mut self, val: u32) {
16121 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16122 }
16123 }
16124 impl Default for HuffencAc183 {
16125 #[inline(always)]
16126 fn default() -> HuffencAc183 {
16127 HuffencAc183(0)
16128 }
16129 }
16130 impl core::fmt::Debug for HuffencAc183 {
16131 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16132 f.debug_struct("HuffencAc183")
16133 .field("dhtmem_ram", &self.dhtmem_ram())
16134 .finish()
16135 }
16136 }
16137 #[cfg(feature = "defmt")]
16138 impl defmt::Format for HuffencAc183 {
16139 fn format(&self, f: defmt::Formatter) {
16140 #[derive(defmt :: Format)]
16141 struct HuffencAc183 {
16142 dhtmem_ram: u32,
16143 }
16144 let proxy = HuffencAc183 {
16145 dhtmem_ram: self.dhtmem_ram(),
16146 };
16147 defmt::write!(f, "{}", proxy)
16148 }
16149 }
16150 #[doc = "JPEG encoder, AC Huffman table 1"]
16151 #[repr(transparent)]
16152 #[derive(Copy, Clone, Eq, PartialEq)]
16153 pub struct HuffencAc184(pub u32);
16154 impl HuffencAc184 {
16155 #[doc = "DHTMem RAM"]
16156 #[inline(always)]
16157 pub const fn dhtmem_ram(&self) -> u32 {
16158 let val = (self.0 >> 0usize) & 0xffff_ffff;
16159 val as u32
16160 }
16161 #[doc = "DHTMem RAM"]
16162 #[inline(always)]
16163 pub fn set_dhtmem_ram(&mut self, val: u32) {
16164 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16165 }
16166 }
16167 impl Default for HuffencAc184 {
16168 #[inline(always)]
16169 fn default() -> HuffencAc184 {
16170 HuffencAc184(0)
16171 }
16172 }
16173 impl core::fmt::Debug for HuffencAc184 {
16174 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16175 f.debug_struct("HuffencAc184")
16176 .field("dhtmem_ram", &self.dhtmem_ram())
16177 .finish()
16178 }
16179 }
16180 #[cfg(feature = "defmt")]
16181 impl defmt::Format for HuffencAc184 {
16182 fn format(&self, f: defmt::Formatter) {
16183 #[derive(defmt :: Format)]
16184 struct HuffencAc184 {
16185 dhtmem_ram: u32,
16186 }
16187 let proxy = HuffencAc184 {
16188 dhtmem_ram: self.dhtmem_ram(),
16189 };
16190 defmt::write!(f, "{}", proxy)
16191 }
16192 }
16193 #[doc = "JPEG encoder, AC Huffman table 1"]
16194 #[repr(transparent)]
16195 #[derive(Copy, Clone, Eq, PartialEq)]
16196 pub struct HuffencAc185(pub u32);
16197 impl HuffencAc185 {
16198 #[doc = "DHTMem RAM"]
16199 #[inline(always)]
16200 pub const fn dhtmem_ram(&self) -> u32 {
16201 let val = (self.0 >> 0usize) & 0xffff_ffff;
16202 val as u32
16203 }
16204 #[doc = "DHTMem RAM"]
16205 #[inline(always)]
16206 pub fn set_dhtmem_ram(&mut self, val: u32) {
16207 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16208 }
16209 }
16210 impl Default for HuffencAc185 {
16211 #[inline(always)]
16212 fn default() -> HuffencAc185 {
16213 HuffencAc185(0)
16214 }
16215 }
16216 impl core::fmt::Debug for HuffencAc185 {
16217 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16218 f.debug_struct("HuffencAc185")
16219 .field("dhtmem_ram", &self.dhtmem_ram())
16220 .finish()
16221 }
16222 }
16223 #[cfg(feature = "defmt")]
16224 impl defmt::Format for HuffencAc185 {
16225 fn format(&self, f: defmt::Formatter) {
16226 #[derive(defmt :: Format)]
16227 struct HuffencAc185 {
16228 dhtmem_ram: u32,
16229 }
16230 let proxy = HuffencAc185 {
16231 dhtmem_ram: self.dhtmem_ram(),
16232 };
16233 defmt::write!(f, "{}", proxy)
16234 }
16235 }
16236 #[doc = "JPEG encoder, AC Huffman table 1"]
16237 #[repr(transparent)]
16238 #[derive(Copy, Clone, Eq, PartialEq)]
16239 pub struct HuffencAc186(pub u32);
16240 impl HuffencAc186 {
16241 #[doc = "DHTMem RAM"]
16242 #[inline(always)]
16243 pub const fn dhtmem_ram(&self) -> u32 {
16244 let val = (self.0 >> 0usize) & 0xffff_ffff;
16245 val as u32
16246 }
16247 #[doc = "DHTMem RAM"]
16248 #[inline(always)]
16249 pub fn set_dhtmem_ram(&mut self, val: u32) {
16250 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16251 }
16252 }
16253 impl Default for HuffencAc186 {
16254 #[inline(always)]
16255 fn default() -> HuffencAc186 {
16256 HuffencAc186(0)
16257 }
16258 }
16259 impl core::fmt::Debug for HuffencAc186 {
16260 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16261 f.debug_struct("HuffencAc186")
16262 .field("dhtmem_ram", &self.dhtmem_ram())
16263 .finish()
16264 }
16265 }
16266 #[cfg(feature = "defmt")]
16267 impl defmt::Format for HuffencAc186 {
16268 fn format(&self, f: defmt::Formatter) {
16269 #[derive(defmt :: Format)]
16270 struct HuffencAc186 {
16271 dhtmem_ram: u32,
16272 }
16273 let proxy = HuffencAc186 {
16274 dhtmem_ram: self.dhtmem_ram(),
16275 };
16276 defmt::write!(f, "{}", proxy)
16277 }
16278 }
16279 #[doc = "JPEG encoder, AC Huffman table 1"]
16280 #[repr(transparent)]
16281 #[derive(Copy, Clone, Eq, PartialEq)]
16282 pub struct HuffencAc187(pub u32);
16283 impl HuffencAc187 {
16284 #[doc = "DHTMem RAM"]
16285 #[inline(always)]
16286 pub const fn dhtmem_ram(&self) -> u32 {
16287 let val = (self.0 >> 0usize) & 0xffff_ffff;
16288 val as u32
16289 }
16290 #[doc = "DHTMem RAM"]
16291 #[inline(always)]
16292 pub fn set_dhtmem_ram(&mut self, val: u32) {
16293 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16294 }
16295 }
16296 impl Default for HuffencAc187 {
16297 #[inline(always)]
16298 fn default() -> HuffencAc187 {
16299 HuffencAc187(0)
16300 }
16301 }
16302 impl core::fmt::Debug for HuffencAc187 {
16303 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16304 f.debug_struct("HuffencAc187")
16305 .field("dhtmem_ram", &self.dhtmem_ram())
16306 .finish()
16307 }
16308 }
16309 #[cfg(feature = "defmt")]
16310 impl defmt::Format for HuffencAc187 {
16311 fn format(&self, f: defmt::Formatter) {
16312 #[derive(defmt :: Format)]
16313 struct HuffencAc187 {
16314 dhtmem_ram: u32,
16315 }
16316 let proxy = HuffencAc187 {
16317 dhtmem_ram: self.dhtmem_ram(),
16318 };
16319 defmt::write!(f, "{}", proxy)
16320 }
16321 }
16322 #[doc = "JPEG encoder, AC Huffman table 1"]
16323 #[repr(transparent)]
16324 #[derive(Copy, Clone, Eq, PartialEq)]
16325 pub struct HuffencAc19(pub u32);
16326 impl HuffencAc19 {
16327 #[doc = "DHTMem RAM"]
16328 #[inline(always)]
16329 pub const fn dhtmem_ram(&self) -> u32 {
16330 let val = (self.0 >> 0usize) & 0xffff_ffff;
16331 val as u32
16332 }
16333 #[doc = "DHTMem RAM"]
16334 #[inline(always)]
16335 pub fn set_dhtmem_ram(&mut self, val: u32) {
16336 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16337 }
16338 }
16339 impl Default for HuffencAc19 {
16340 #[inline(always)]
16341 fn default() -> HuffencAc19 {
16342 HuffencAc19(0)
16343 }
16344 }
16345 impl core::fmt::Debug for HuffencAc19 {
16346 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16347 f.debug_struct("HuffencAc19")
16348 .field("dhtmem_ram", &self.dhtmem_ram())
16349 .finish()
16350 }
16351 }
16352 #[cfg(feature = "defmt")]
16353 impl defmt::Format for HuffencAc19 {
16354 fn format(&self, f: defmt::Formatter) {
16355 #[derive(defmt :: Format)]
16356 struct HuffencAc19 {
16357 dhtmem_ram: u32,
16358 }
16359 let proxy = HuffencAc19 {
16360 dhtmem_ram: self.dhtmem_ram(),
16361 };
16362 defmt::write!(f, "{}", proxy)
16363 }
16364 }
16365 #[doc = "JPEG encoder, DC Huffman table 0"]
16366 #[repr(transparent)]
16367 #[derive(Copy, Clone, Eq, PartialEq)]
16368 pub struct HuffencDc00(pub u32);
16369 impl HuffencDc00 {
16370 #[doc = "DHTMem RAM"]
16371 #[inline(always)]
16372 pub const fn dhtmem_ram(&self) -> u32 {
16373 let val = (self.0 >> 0usize) & 0xffff_ffff;
16374 val as u32
16375 }
16376 #[doc = "DHTMem RAM"]
16377 #[inline(always)]
16378 pub fn set_dhtmem_ram(&mut self, val: u32) {
16379 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16380 }
16381 }
16382 impl Default for HuffencDc00 {
16383 #[inline(always)]
16384 fn default() -> HuffencDc00 {
16385 HuffencDc00(0)
16386 }
16387 }
16388 impl core::fmt::Debug for HuffencDc00 {
16389 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16390 f.debug_struct("HuffencDc00")
16391 .field("dhtmem_ram", &self.dhtmem_ram())
16392 .finish()
16393 }
16394 }
16395 #[cfg(feature = "defmt")]
16396 impl defmt::Format for HuffencDc00 {
16397 fn format(&self, f: defmt::Formatter) {
16398 #[derive(defmt :: Format)]
16399 struct HuffencDc00 {
16400 dhtmem_ram: u32,
16401 }
16402 let proxy = HuffencDc00 {
16403 dhtmem_ram: self.dhtmem_ram(),
16404 };
16405 defmt::write!(f, "{}", proxy)
16406 }
16407 }
16408 #[doc = "JPEG encoder, DC Huffman table 0"]
16409 #[repr(transparent)]
16410 #[derive(Copy, Clone, Eq, PartialEq)]
16411 pub struct HuffencDc01(pub u32);
16412 impl HuffencDc01 {
16413 #[doc = "DHTMem RAM"]
16414 #[inline(always)]
16415 pub const fn dhtmem_ram(&self) -> u32 {
16416 let val = (self.0 >> 0usize) & 0xffff_ffff;
16417 val as u32
16418 }
16419 #[doc = "DHTMem RAM"]
16420 #[inline(always)]
16421 pub fn set_dhtmem_ram(&mut self, val: u32) {
16422 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16423 }
16424 }
16425 impl Default for HuffencDc01 {
16426 #[inline(always)]
16427 fn default() -> HuffencDc01 {
16428 HuffencDc01(0)
16429 }
16430 }
16431 impl core::fmt::Debug for HuffencDc01 {
16432 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16433 f.debug_struct("HuffencDc01")
16434 .field("dhtmem_ram", &self.dhtmem_ram())
16435 .finish()
16436 }
16437 }
16438 #[cfg(feature = "defmt")]
16439 impl defmt::Format for HuffencDc01 {
16440 fn format(&self, f: defmt::Formatter) {
16441 #[derive(defmt :: Format)]
16442 struct HuffencDc01 {
16443 dhtmem_ram: u32,
16444 }
16445 let proxy = HuffencDc01 {
16446 dhtmem_ram: self.dhtmem_ram(),
16447 };
16448 defmt::write!(f, "{}", proxy)
16449 }
16450 }
16451 #[doc = "JPEG encoder, DC Huffman table 0"]
16452 #[repr(transparent)]
16453 #[derive(Copy, Clone, Eq, PartialEq)]
16454 pub struct HuffencDc02(pub u32);
16455 impl HuffencDc02 {
16456 #[doc = "DHTMem RAM"]
16457 #[inline(always)]
16458 pub const fn dhtmem_ram(&self) -> u32 {
16459 let val = (self.0 >> 0usize) & 0xffff_ffff;
16460 val as u32
16461 }
16462 #[doc = "DHTMem RAM"]
16463 #[inline(always)]
16464 pub fn set_dhtmem_ram(&mut self, val: u32) {
16465 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16466 }
16467 }
16468 impl Default for HuffencDc02 {
16469 #[inline(always)]
16470 fn default() -> HuffencDc02 {
16471 HuffencDc02(0)
16472 }
16473 }
16474 impl core::fmt::Debug for HuffencDc02 {
16475 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16476 f.debug_struct("HuffencDc02")
16477 .field("dhtmem_ram", &self.dhtmem_ram())
16478 .finish()
16479 }
16480 }
16481 #[cfg(feature = "defmt")]
16482 impl defmt::Format for HuffencDc02 {
16483 fn format(&self, f: defmt::Formatter) {
16484 #[derive(defmt :: Format)]
16485 struct HuffencDc02 {
16486 dhtmem_ram: u32,
16487 }
16488 let proxy = HuffencDc02 {
16489 dhtmem_ram: self.dhtmem_ram(),
16490 };
16491 defmt::write!(f, "{}", proxy)
16492 }
16493 }
16494 #[doc = "JPEG encoder, DC Huffman table 0"]
16495 #[repr(transparent)]
16496 #[derive(Copy, Clone, Eq, PartialEq)]
16497 pub struct HuffencDc03(pub u32);
16498 impl HuffencDc03 {
16499 #[doc = "DHTMem RAM"]
16500 #[inline(always)]
16501 pub const fn dhtmem_ram(&self) -> u32 {
16502 let val = (self.0 >> 0usize) & 0xffff_ffff;
16503 val as u32
16504 }
16505 #[doc = "DHTMem RAM"]
16506 #[inline(always)]
16507 pub fn set_dhtmem_ram(&mut self, val: u32) {
16508 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16509 }
16510 }
16511 impl Default for HuffencDc03 {
16512 #[inline(always)]
16513 fn default() -> HuffencDc03 {
16514 HuffencDc03(0)
16515 }
16516 }
16517 impl core::fmt::Debug for HuffencDc03 {
16518 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16519 f.debug_struct("HuffencDc03")
16520 .field("dhtmem_ram", &self.dhtmem_ram())
16521 .finish()
16522 }
16523 }
16524 #[cfg(feature = "defmt")]
16525 impl defmt::Format for HuffencDc03 {
16526 fn format(&self, f: defmt::Formatter) {
16527 #[derive(defmt :: Format)]
16528 struct HuffencDc03 {
16529 dhtmem_ram: u32,
16530 }
16531 let proxy = HuffencDc03 {
16532 dhtmem_ram: self.dhtmem_ram(),
16533 };
16534 defmt::write!(f, "{}", proxy)
16535 }
16536 }
16537 #[doc = "JPEG encoder, DC Huffman table 0"]
16538 #[repr(transparent)]
16539 #[derive(Copy, Clone, Eq, PartialEq)]
16540 pub struct HuffencDc04(pub u32);
16541 impl HuffencDc04 {
16542 #[doc = "DHTMem RAM"]
16543 #[inline(always)]
16544 pub const fn dhtmem_ram(&self) -> u32 {
16545 let val = (self.0 >> 0usize) & 0xffff_ffff;
16546 val as u32
16547 }
16548 #[doc = "DHTMem RAM"]
16549 #[inline(always)]
16550 pub fn set_dhtmem_ram(&mut self, val: u32) {
16551 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16552 }
16553 }
16554 impl Default for HuffencDc04 {
16555 #[inline(always)]
16556 fn default() -> HuffencDc04 {
16557 HuffencDc04(0)
16558 }
16559 }
16560 impl core::fmt::Debug for HuffencDc04 {
16561 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16562 f.debug_struct("HuffencDc04")
16563 .field("dhtmem_ram", &self.dhtmem_ram())
16564 .finish()
16565 }
16566 }
16567 #[cfg(feature = "defmt")]
16568 impl defmt::Format for HuffencDc04 {
16569 fn format(&self, f: defmt::Formatter) {
16570 #[derive(defmt :: Format)]
16571 struct HuffencDc04 {
16572 dhtmem_ram: u32,
16573 }
16574 let proxy = HuffencDc04 {
16575 dhtmem_ram: self.dhtmem_ram(),
16576 };
16577 defmt::write!(f, "{}", proxy)
16578 }
16579 }
16580 #[doc = "JPEG encoder, DC Huffman table 0"]
16581 #[repr(transparent)]
16582 #[derive(Copy, Clone, Eq, PartialEq)]
16583 pub struct HuffencDc05(pub u32);
16584 impl HuffencDc05 {
16585 #[doc = "DHTMem RAM"]
16586 #[inline(always)]
16587 pub const fn dhtmem_ram(&self) -> u32 {
16588 let val = (self.0 >> 0usize) & 0xffff_ffff;
16589 val as u32
16590 }
16591 #[doc = "DHTMem RAM"]
16592 #[inline(always)]
16593 pub fn set_dhtmem_ram(&mut self, val: u32) {
16594 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16595 }
16596 }
16597 impl Default for HuffencDc05 {
16598 #[inline(always)]
16599 fn default() -> HuffencDc05 {
16600 HuffencDc05(0)
16601 }
16602 }
16603 impl core::fmt::Debug for HuffencDc05 {
16604 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16605 f.debug_struct("HuffencDc05")
16606 .field("dhtmem_ram", &self.dhtmem_ram())
16607 .finish()
16608 }
16609 }
16610 #[cfg(feature = "defmt")]
16611 impl defmt::Format for HuffencDc05 {
16612 fn format(&self, f: defmt::Formatter) {
16613 #[derive(defmt :: Format)]
16614 struct HuffencDc05 {
16615 dhtmem_ram: u32,
16616 }
16617 let proxy = HuffencDc05 {
16618 dhtmem_ram: self.dhtmem_ram(),
16619 };
16620 defmt::write!(f, "{}", proxy)
16621 }
16622 }
16623 #[doc = "JPEG encoder, DC Huffman table 0"]
16624 #[repr(transparent)]
16625 #[derive(Copy, Clone, Eq, PartialEq)]
16626 pub struct HuffencDc06(pub u32);
16627 impl HuffencDc06 {
16628 #[doc = "DHTMem RAM"]
16629 #[inline(always)]
16630 pub const fn dhtmem_ram(&self) -> u32 {
16631 let val = (self.0 >> 0usize) & 0xffff_ffff;
16632 val as u32
16633 }
16634 #[doc = "DHTMem RAM"]
16635 #[inline(always)]
16636 pub fn set_dhtmem_ram(&mut self, val: u32) {
16637 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16638 }
16639 }
16640 impl Default for HuffencDc06 {
16641 #[inline(always)]
16642 fn default() -> HuffencDc06 {
16643 HuffencDc06(0)
16644 }
16645 }
16646 impl core::fmt::Debug for HuffencDc06 {
16647 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16648 f.debug_struct("HuffencDc06")
16649 .field("dhtmem_ram", &self.dhtmem_ram())
16650 .finish()
16651 }
16652 }
16653 #[cfg(feature = "defmt")]
16654 impl defmt::Format for HuffencDc06 {
16655 fn format(&self, f: defmt::Formatter) {
16656 #[derive(defmt :: Format)]
16657 struct HuffencDc06 {
16658 dhtmem_ram: u32,
16659 }
16660 let proxy = HuffencDc06 {
16661 dhtmem_ram: self.dhtmem_ram(),
16662 };
16663 defmt::write!(f, "{}", proxy)
16664 }
16665 }
16666 #[doc = "JPEG encoder, DC Huffman table 0"]
16667 #[repr(transparent)]
16668 #[derive(Copy, Clone, Eq, PartialEq)]
16669 pub struct HuffencDc07(pub u32);
16670 impl HuffencDc07 {
16671 #[doc = "DHTMem RAM"]
16672 #[inline(always)]
16673 pub const fn dhtmem_ram(&self) -> u32 {
16674 let val = (self.0 >> 0usize) & 0xffff_ffff;
16675 val as u32
16676 }
16677 #[doc = "DHTMem RAM"]
16678 #[inline(always)]
16679 pub fn set_dhtmem_ram(&mut self, val: u32) {
16680 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16681 }
16682 }
16683 impl Default for HuffencDc07 {
16684 #[inline(always)]
16685 fn default() -> HuffencDc07 {
16686 HuffencDc07(0)
16687 }
16688 }
16689 impl core::fmt::Debug for HuffencDc07 {
16690 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16691 f.debug_struct("HuffencDc07")
16692 .field("dhtmem_ram", &self.dhtmem_ram())
16693 .finish()
16694 }
16695 }
16696 #[cfg(feature = "defmt")]
16697 impl defmt::Format for HuffencDc07 {
16698 fn format(&self, f: defmt::Formatter) {
16699 #[derive(defmt :: Format)]
16700 struct HuffencDc07 {
16701 dhtmem_ram: u32,
16702 }
16703 let proxy = HuffencDc07 {
16704 dhtmem_ram: self.dhtmem_ram(),
16705 };
16706 defmt::write!(f, "{}", proxy)
16707 }
16708 }
16709 #[doc = "JPEG encoder, DC Huffman table 1"]
16710 #[repr(transparent)]
16711 #[derive(Copy, Clone, Eq, PartialEq)]
16712 pub struct HuffencDc10(pub u32);
16713 impl HuffencDc10 {
16714 #[doc = "DHTMem RAM"]
16715 #[inline(always)]
16716 pub const fn dhtmem_ram(&self) -> u32 {
16717 let val = (self.0 >> 0usize) & 0xffff_ffff;
16718 val as u32
16719 }
16720 #[doc = "DHTMem RAM"]
16721 #[inline(always)]
16722 pub fn set_dhtmem_ram(&mut self, val: u32) {
16723 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16724 }
16725 }
16726 impl Default for HuffencDc10 {
16727 #[inline(always)]
16728 fn default() -> HuffencDc10 {
16729 HuffencDc10(0)
16730 }
16731 }
16732 impl core::fmt::Debug for HuffencDc10 {
16733 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16734 f.debug_struct("HuffencDc10")
16735 .field("dhtmem_ram", &self.dhtmem_ram())
16736 .finish()
16737 }
16738 }
16739 #[cfg(feature = "defmt")]
16740 impl defmt::Format for HuffencDc10 {
16741 fn format(&self, f: defmt::Formatter) {
16742 #[derive(defmt :: Format)]
16743 struct HuffencDc10 {
16744 dhtmem_ram: u32,
16745 }
16746 let proxy = HuffencDc10 {
16747 dhtmem_ram: self.dhtmem_ram(),
16748 };
16749 defmt::write!(f, "{}", proxy)
16750 }
16751 }
16752 #[doc = "JPEG encoder, DC Huffman table 1"]
16753 #[repr(transparent)]
16754 #[derive(Copy, Clone, Eq, PartialEq)]
16755 pub struct HuffencDc11(pub u32);
16756 impl HuffencDc11 {
16757 #[doc = "DHTMem RAM"]
16758 #[inline(always)]
16759 pub const fn dhtmem_ram(&self) -> u32 {
16760 let val = (self.0 >> 0usize) & 0xffff_ffff;
16761 val as u32
16762 }
16763 #[doc = "DHTMem RAM"]
16764 #[inline(always)]
16765 pub fn set_dhtmem_ram(&mut self, val: u32) {
16766 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16767 }
16768 }
16769 impl Default for HuffencDc11 {
16770 #[inline(always)]
16771 fn default() -> HuffencDc11 {
16772 HuffencDc11(0)
16773 }
16774 }
16775 impl core::fmt::Debug for HuffencDc11 {
16776 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16777 f.debug_struct("HuffencDc11")
16778 .field("dhtmem_ram", &self.dhtmem_ram())
16779 .finish()
16780 }
16781 }
16782 #[cfg(feature = "defmt")]
16783 impl defmt::Format for HuffencDc11 {
16784 fn format(&self, f: defmt::Formatter) {
16785 #[derive(defmt :: Format)]
16786 struct HuffencDc11 {
16787 dhtmem_ram: u32,
16788 }
16789 let proxy = HuffencDc11 {
16790 dhtmem_ram: self.dhtmem_ram(),
16791 };
16792 defmt::write!(f, "{}", proxy)
16793 }
16794 }
16795 #[doc = "JPEG encoder, DC Huffman table 1"]
16796 #[repr(transparent)]
16797 #[derive(Copy, Clone, Eq, PartialEq)]
16798 pub struct HuffencDc12(pub u32);
16799 impl HuffencDc12 {
16800 #[doc = "DHTMem RAM"]
16801 #[inline(always)]
16802 pub const fn dhtmem_ram(&self) -> u32 {
16803 let val = (self.0 >> 0usize) & 0xffff_ffff;
16804 val as u32
16805 }
16806 #[doc = "DHTMem RAM"]
16807 #[inline(always)]
16808 pub fn set_dhtmem_ram(&mut self, val: u32) {
16809 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16810 }
16811 }
16812 impl Default for HuffencDc12 {
16813 #[inline(always)]
16814 fn default() -> HuffencDc12 {
16815 HuffencDc12(0)
16816 }
16817 }
16818 impl core::fmt::Debug for HuffencDc12 {
16819 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16820 f.debug_struct("HuffencDc12")
16821 .field("dhtmem_ram", &self.dhtmem_ram())
16822 .finish()
16823 }
16824 }
16825 #[cfg(feature = "defmt")]
16826 impl defmt::Format for HuffencDc12 {
16827 fn format(&self, f: defmt::Formatter) {
16828 #[derive(defmt :: Format)]
16829 struct HuffencDc12 {
16830 dhtmem_ram: u32,
16831 }
16832 let proxy = HuffencDc12 {
16833 dhtmem_ram: self.dhtmem_ram(),
16834 };
16835 defmt::write!(f, "{}", proxy)
16836 }
16837 }
16838 #[doc = "JPEG encoder, DC Huffman table 1"]
16839 #[repr(transparent)]
16840 #[derive(Copy, Clone, Eq, PartialEq)]
16841 pub struct HuffencDc13(pub u32);
16842 impl HuffencDc13 {
16843 #[doc = "DHTMem RAM"]
16844 #[inline(always)]
16845 pub const fn dhtmem_ram(&self) -> u32 {
16846 let val = (self.0 >> 0usize) & 0xffff_ffff;
16847 val as u32
16848 }
16849 #[doc = "DHTMem RAM"]
16850 #[inline(always)]
16851 pub fn set_dhtmem_ram(&mut self, val: u32) {
16852 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16853 }
16854 }
16855 impl Default for HuffencDc13 {
16856 #[inline(always)]
16857 fn default() -> HuffencDc13 {
16858 HuffencDc13(0)
16859 }
16860 }
16861 impl core::fmt::Debug for HuffencDc13 {
16862 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16863 f.debug_struct("HuffencDc13")
16864 .field("dhtmem_ram", &self.dhtmem_ram())
16865 .finish()
16866 }
16867 }
16868 #[cfg(feature = "defmt")]
16869 impl defmt::Format for HuffencDc13 {
16870 fn format(&self, f: defmt::Formatter) {
16871 #[derive(defmt :: Format)]
16872 struct HuffencDc13 {
16873 dhtmem_ram: u32,
16874 }
16875 let proxy = HuffencDc13 {
16876 dhtmem_ram: self.dhtmem_ram(),
16877 };
16878 defmt::write!(f, "{}", proxy)
16879 }
16880 }
16881 #[doc = "JPEG encoder, DC Huffman table 1"]
16882 #[repr(transparent)]
16883 #[derive(Copy, Clone, Eq, PartialEq)]
16884 pub struct HuffencDc14(pub u32);
16885 impl HuffencDc14 {
16886 #[doc = "DHTMem RAM"]
16887 #[inline(always)]
16888 pub const fn dhtmem_ram(&self) -> u32 {
16889 let val = (self.0 >> 0usize) & 0xffff_ffff;
16890 val as u32
16891 }
16892 #[doc = "DHTMem RAM"]
16893 #[inline(always)]
16894 pub fn set_dhtmem_ram(&mut self, val: u32) {
16895 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16896 }
16897 }
16898 impl Default for HuffencDc14 {
16899 #[inline(always)]
16900 fn default() -> HuffencDc14 {
16901 HuffencDc14(0)
16902 }
16903 }
16904 impl core::fmt::Debug for HuffencDc14 {
16905 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16906 f.debug_struct("HuffencDc14")
16907 .field("dhtmem_ram", &self.dhtmem_ram())
16908 .finish()
16909 }
16910 }
16911 #[cfg(feature = "defmt")]
16912 impl defmt::Format for HuffencDc14 {
16913 fn format(&self, f: defmt::Formatter) {
16914 #[derive(defmt :: Format)]
16915 struct HuffencDc14 {
16916 dhtmem_ram: u32,
16917 }
16918 let proxy = HuffencDc14 {
16919 dhtmem_ram: self.dhtmem_ram(),
16920 };
16921 defmt::write!(f, "{}", proxy)
16922 }
16923 }
16924 #[doc = "JPEG encoder, DC Huffman table 1"]
16925 #[repr(transparent)]
16926 #[derive(Copy, Clone, Eq, PartialEq)]
16927 pub struct HuffencDc15(pub u32);
16928 impl HuffencDc15 {
16929 #[doc = "DHTMem RAM"]
16930 #[inline(always)]
16931 pub const fn dhtmem_ram(&self) -> u32 {
16932 let val = (self.0 >> 0usize) & 0xffff_ffff;
16933 val as u32
16934 }
16935 #[doc = "DHTMem RAM"]
16936 #[inline(always)]
16937 pub fn set_dhtmem_ram(&mut self, val: u32) {
16938 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16939 }
16940 }
16941 impl Default for HuffencDc15 {
16942 #[inline(always)]
16943 fn default() -> HuffencDc15 {
16944 HuffencDc15(0)
16945 }
16946 }
16947 impl core::fmt::Debug for HuffencDc15 {
16948 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16949 f.debug_struct("HuffencDc15")
16950 .field("dhtmem_ram", &self.dhtmem_ram())
16951 .finish()
16952 }
16953 }
16954 #[cfg(feature = "defmt")]
16955 impl defmt::Format for HuffencDc15 {
16956 fn format(&self, f: defmt::Formatter) {
16957 #[derive(defmt :: Format)]
16958 struct HuffencDc15 {
16959 dhtmem_ram: u32,
16960 }
16961 let proxy = HuffencDc15 {
16962 dhtmem_ram: self.dhtmem_ram(),
16963 };
16964 defmt::write!(f, "{}", proxy)
16965 }
16966 }
16967 #[doc = "JPEG encoder, DC Huffman table 1"]
16968 #[repr(transparent)]
16969 #[derive(Copy, Clone, Eq, PartialEq)]
16970 pub struct HuffencDc16(pub u32);
16971 impl HuffencDc16 {
16972 #[doc = "DHTMem RAM"]
16973 #[inline(always)]
16974 pub const fn dhtmem_ram(&self) -> u32 {
16975 let val = (self.0 >> 0usize) & 0xffff_ffff;
16976 val as u32
16977 }
16978 #[doc = "DHTMem RAM"]
16979 #[inline(always)]
16980 pub fn set_dhtmem_ram(&mut self, val: u32) {
16981 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
16982 }
16983 }
16984 impl Default for HuffencDc16 {
16985 #[inline(always)]
16986 fn default() -> HuffencDc16 {
16987 HuffencDc16(0)
16988 }
16989 }
16990 impl core::fmt::Debug for HuffencDc16 {
16991 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
16992 f.debug_struct("HuffencDc16")
16993 .field("dhtmem_ram", &self.dhtmem_ram())
16994 .finish()
16995 }
16996 }
16997 #[cfg(feature = "defmt")]
16998 impl defmt::Format for HuffencDc16 {
16999 fn format(&self, f: defmt::Formatter) {
17000 #[derive(defmt :: Format)]
17001 struct HuffencDc16 {
17002 dhtmem_ram: u32,
17003 }
17004 let proxy = HuffencDc16 {
17005 dhtmem_ram: self.dhtmem_ram(),
17006 };
17007 defmt::write!(f, "{}", proxy)
17008 }
17009 }
17010 #[doc = "JPEG encoder, DC Huffman table 1"]
17011 #[repr(transparent)]
17012 #[derive(Copy, Clone, Eq, PartialEq)]
17013 pub struct HuffencDc17(pub u32);
17014 impl HuffencDc17 {
17015 #[doc = "DHTMem RAM"]
17016 #[inline(always)]
17017 pub const fn dhtmem_ram(&self) -> u32 {
17018 let val = (self.0 >> 0usize) & 0xffff_ffff;
17019 val as u32
17020 }
17021 #[doc = "DHTMem RAM"]
17022 #[inline(always)]
17023 pub fn set_dhtmem_ram(&mut self, val: u32) {
17024 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17025 }
17026 }
17027 impl Default for HuffencDc17 {
17028 #[inline(always)]
17029 fn default() -> HuffencDc17 {
17030 HuffencDc17(0)
17031 }
17032 }
17033 impl core::fmt::Debug for HuffencDc17 {
17034 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17035 f.debug_struct("HuffencDc17")
17036 .field("dhtmem_ram", &self.dhtmem_ram())
17037 .finish()
17038 }
17039 }
17040 #[cfg(feature = "defmt")]
17041 impl defmt::Format for HuffencDc17 {
17042 fn format(&self, f: defmt::Formatter) {
17043 #[derive(defmt :: Format)]
17044 struct HuffencDc17 {
17045 dhtmem_ram: u32,
17046 }
17047 let proxy = HuffencDc17 {
17048 dhtmem_ram: self.dhtmem_ram(),
17049 };
17050 defmt::write!(f, "{}", proxy)
17051 }
17052 }
17053 #[doc = "JPEG HuffMin tables"]
17054 #[repr(transparent)]
17055 #[derive(Copy, Clone, Eq, PartialEq)]
17056 pub struct Huffmin0(pub u32);
17057 impl Huffmin0 {
17058 #[doc = "HuffMin RAM"]
17059 #[inline(always)]
17060 pub const fn huff_min_ram(&self) -> u32 {
17061 let val = (self.0 >> 0usize) & 0xffff_ffff;
17062 val as u32
17063 }
17064 #[doc = "HuffMin RAM"]
17065 #[inline(always)]
17066 pub fn set_huff_min_ram(&mut self, val: u32) {
17067 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17068 }
17069 }
17070 impl Default for Huffmin0 {
17071 #[inline(always)]
17072 fn default() -> Huffmin0 {
17073 Huffmin0(0)
17074 }
17075 }
17076 impl core::fmt::Debug for Huffmin0 {
17077 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17078 f.debug_struct("Huffmin0")
17079 .field("huff_min_ram", &self.huff_min_ram())
17080 .finish()
17081 }
17082 }
17083 #[cfg(feature = "defmt")]
17084 impl defmt::Format for Huffmin0 {
17085 fn format(&self, f: defmt::Formatter) {
17086 #[derive(defmt :: Format)]
17087 struct Huffmin0 {
17088 huff_min_ram: u32,
17089 }
17090 let proxy = Huffmin0 {
17091 huff_min_ram: self.huff_min_ram(),
17092 };
17093 defmt::write!(f, "{}", proxy)
17094 }
17095 }
17096 #[doc = "JPEG HuffMin tables"]
17097 #[repr(transparent)]
17098 #[derive(Copy, Clone, Eq, PartialEq)]
17099 pub struct Huffmin1(pub u32);
17100 impl Huffmin1 {
17101 #[doc = "HuffMin RAM"]
17102 #[inline(always)]
17103 pub const fn huff_min_ram(&self) -> u32 {
17104 let val = (self.0 >> 0usize) & 0xffff_ffff;
17105 val as u32
17106 }
17107 #[doc = "HuffMin RAM"]
17108 #[inline(always)]
17109 pub fn set_huff_min_ram(&mut self, val: u32) {
17110 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17111 }
17112 }
17113 impl Default for Huffmin1 {
17114 #[inline(always)]
17115 fn default() -> Huffmin1 {
17116 Huffmin1(0)
17117 }
17118 }
17119 impl core::fmt::Debug for Huffmin1 {
17120 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17121 f.debug_struct("Huffmin1")
17122 .field("huff_min_ram", &self.huff_min_ram())
17123 .finish()
17124 }
17125 }
17126 #[cfg(feature = "defmt")]
17127 impl defmt::Format for Huffmin1 {
17128 fn format(&self, f: defmt::Formatter) {
17129 #[derive(defmt :: Format)]
17130 struct Huffmin1 {
17131 huff_min_ram: u32,
17132 }
17133 let proxy = Huffmin1 {
17134 huff_min_ram: self.huff_min_ram(),
17135 };
17136 defmt::write!(f, "{}", proxy)
17137 }
17138 }
17139 #[doc = "JPEG HuffMin tables"]
17140 #[repr(transparent)]
17141 #[derive(Copy, Clone, Eq, PartialEq)]
17142 pub struct Huffmin10(pub u32);
17143 impl Huffmin10 {
17144 #[doc = "HuffMin RAM"]
17145 #[inline(always)]
17146 pub const fn huff_min_ram(&self) -> u32 {
17147 let val = (self.0 >> 0usize) & 0xffff_ffff;
17148 val as u32
17149 }
17150 #[doc = "HuffMin RAM"]
17151 #[inline(always)]
17152 pub fn set_huff_min_ram(&mut self, val: u32) {
17153 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17154 }
17155 }
17156 impl Default for Huffmin10 {
17157 #[inline(always)]
17158 fn default() -> Huffmin10 {
17159 Huffmin10(0)
17160 }
17161 }
17162 impl core::fmt::Debug for Huffmin10 {
17163 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17164 f.debug_struct("Huffmin10")
17165 .field("huff_min_ram", &self.huff_min_ram())
17166 .finish()
17167 }
17168 }
17169 #[cfg(feature = "defmt")]
17170 impl defmt::Format for Huffmin10 {
17171 fn format(&self, f: defmt::Formatter) {
17172 #[derive(defmt :: Format)]
17173 struct Huffmin10 {
17174 huff_min_ram: u32,
17175 }
17176 let proxy = Huffmin10 {
17177 huff_min_ram: self.huff_min_ram(),
17178 };
17179 defmt::write!(f, "{}", proxy)
17180 }
17181 }
17182 #[doc = "JPEG HuffMin tables"]
17183 #[repr(transparent)]
17184 #[derive(Copy, Clone, Eq, PartialEq)]
17185 pub struct Huffmin11(pub u32);
17186 impl Huffmin11 {
17187 #[doc = "HuffMin RAM"]
17188 #[inline(always)]
17189 pub const fn huff_min_ram(&self) -> u32 {
17190 let val = (self.0 >> 0usize) & 0xffff_ffff;
17191 val as u32
17192 }
17193 #[doc = "HuffMin RAM"]
17194 #[inline(always)]
17195 pub fn set_huff_min_ram(&mut self, val: u32) {
17196 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17197 }
17198 }
17199 impl Default for Huffmin11 {
17200 #[inline(always)]
17201 fn default() -> Huffmin11 {
17202 Huffmin11(0)
17203 }
17204 }
17205 impl core::fmt::Debug for Huffmin11 {
17206 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17207 f.debug_struct("Huffmin11")
17208 .field("huff_min_ram", &self.huff_min_ram())
17209 .finish()
17210 }
17211 }
17212 #[cfg(feature = "defmt")]
17213 impl defmt::Format for Huffmin11 {
17214 fn format(&self, f: defmt::Formatter) {
17215 #[derive(defmt :: Format)]
17216 struct Huffmin11 {
17217 huff_min_ram: u32,
17218 }
17219 let proxy = Huffmin11 {
17220 huff_min_ram: self.huff_min_ram(),
17221 };
17222 defmt::write!(f, "{}", proxy)
17223 }
17224 }
17225 #[doc = "JPEG HuffMin tables"]
17226 #[repr(transparent)]
17227 #[derive(Copy, Clone, Eq, PartialEq)]
17228 pub struct Huffmin12(pub u32);
17229 impl Huffmin12 {
17230 #[doc = "HuffMin RAM"]
17231 #[inline(always)]
17232 pub const fn huff_min_ram(&self) -> u32 {
17233 let val = (self.0 >> 0usize) & 0xffff_ffff;
17234 val as u32
17235 }
17236 #[doc = "HuffMin RAM"]
17237 #[inline(always)]
17238 pub fn set_huff_min_ram(&mut self, val: u32) {
17239 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17240 }
17241 }
17242 impl Default for Huffmin12 {
17243 #[inline(always)]
17244 fn default() -> Huffmin12 {
17245 Huffmin12(0)
17246 }
17247 }
17248 impl core::fmt::Debug for Huffmin12 {
17249 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17250 f.debug_struct("Huffmin12")
17251 .field("huff_min_ram", &self.huff_min_ram())
17252 .finish()
17253 }
17254 }
17255 #[cfg(feature = "defmt")]
17256 impl defmt::Format for Huffmin12 {
17257 fn format(&self, f: defmt::Formatter) {
17258 #[derive(defmt :: Format)]
17259 struct Huffmin12 {
17260 huff_min_ram: u32,
17261 }
17262 let proxy = Huffmin12 {
17263 huff_min_ram: self.huff_min_ram(),
17264 };
17265 defmt::write!(f, "{}", proxy)
17266 }
17267 }
17268 #[doc = "JPEG HuffMin tables"]
17269 #[repr(transparent)]
17270 #[derive(Copy, Clone, Eq, PartialEq)]
17271 pub struct Huffmin13(pub u32);
17272 impl Huffmin13 {
17273 #[doc = "HuffMin RAM"]
17274 #[inline(always)]
17275 pub const fn huff_min_ram(&self) -> u32 {
17276 let val = (self.0 >> 0usize) & 0xffff_ffff;
17277 val as u32
17278 }
17279 #[doc = "HuffMin RAM"]
17280 #[inline(always)]
17281 pub fn set_huff_min_ram(&mut self, val: u32) {
17282 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17283 }
17284 }
17285 impl Default for Huffmin13 {
17286 #[inline(always)]
17287 fn default() -> Huffmin13 {
17288 Huffmin13(0)
17289 }
17290 }
17291 impl core::fmt::Debug for Huffmin13 {
17292 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17293 f.debug_struct("Huffmin13")
17294 .field("huff_min_ram", &self.huff_min_ram())
17295 .finish()
17296 }
17297 }
17298 #[cfg(feature = "defmt")]
17299 impl defmt::Format for Huffmin13 {
17300 fn format(&self, f: defmt::Formatter) {
17301 #[derive(defmt :: Format)]
17302 struct Huffmin13 {
17303 huff_min_ram: u32,
17304 }
17305 let proxy = Huffmin13 {
17306 huff_min_ram: self.huff_min_ram(),
17307 };
17308 defmt::write!(f, "{}", proxy)
17309 }
17310 }
17311 #[doc = "JPEG HuffMin tables"]
17312 #[repr(transparent)]
17313 #[derive(Copy, Clone, Eq, PartialEq)]
17314 pub struct Huffmin14(pub u32);
17315 impl Huffmin14 {
17316 #[doc = "HuffMin RAM"]
17317 #[inline(always)]
17318 pub const fn huff_min_ram(&self) -> u32 {
17319 let val = (self.0 >> 0usize) & 0xffff_ffff;
17320 val as u32
17321 }
17322 #[doc = "HuffMin RAM"]
17323 #[inline(always)]
17324 pub fn set_huff_min_ram(&mut self, val: u32) {
17325 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17326 }
17327 }
17328 impl Default for Huffmin14 {
17329 #[inline(always)]
17330 fn default() -> Huffmin14 {
17331 Huffmin14(0)
17332 }
17333 }
17334 impl core::fmt::Debug for Huffmin14 {
17335 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17336 f.debug_struct("Huffmin14")
17337 .field("huff_min_ram", &self.huff_min_ram())
17338 .finish()
17339 }
17340 }
17341 #[cfg(feature = "defmt")]
17342 impl defmt::Format for Huffmin14 {
17343 fn format(&self, f: defmt::Formatter) {
17344 #[derive(defmt :: Format)]
17345 struct Huffmin14 {
17346 huff_min_ram: u32,
17347 }
17348 let proxy = Huffmin14 {
17349 huff_min_ram: self.huff_min_ram(),
17350 };
17351 defmt::write!(f, "{}", proxy)
17352 }
17353 }
17354 #[doc = "JPEG HuffMin tables"]
17355 #[repr(transparent)]
17356 #[derive(Copy, Clone, Eq, PartialEq)]
17357 pub struct Huffmin15(pub u32);
17358 impl Huffmin15 {
17359 #[doc = "HuffMin RAM"]
17360 #[inline(always)]
17361 pub const fn huff_min_ram(&self) -> u32 {
17362 let val = (self.0 >> 0usize) & 0xffff_ffff;
17363 val as u32
17364 }
17365 #[doc = "HuffMin RAM"]
17366 #[inline(always)]
17367 pub fn set_huff_min_ram(&mut self, val: u32) {
17368 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17369 }
17370 }
17371 impl Default for Huffmin15 {
17372 #[inline(always)]
17373 fn default() -> Huffmin15 {
17374 Huffmin15(0)
17375 }
17376 }
17377 impl core::fmt::Debug for Huffmin15 {
17378 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17379 f.debug_struct("Huffmin15")
17380 .field("huff_min_ram", &self.huff_min_ram())
17381 .finish()
17382 }
17383 }
17384 #[cfg(feature = "defmt")]
17385 impl defmt::Format for Huffmin15 {
17386 fn format(&self, f: defmt::Formatter) {
17387 #[derive(defmt :: Format)]
17388 struct Huffmin15 {
17389 huff_min_ram: u32,
17390 }
17391 let proxy = Huffmin15 {
17392 huff_min_ram: self.huff_min_ram(),
17393 };
17394 defmt::write!(f, "{}", proxy)
17395 }
17396 }
17397 #[doc = "JPEG HuffMin tables"]
17398 #[repr(transparent)]
17399 #[derive(Copy, Clone, Eq, PartialEq)]
17400 pub struct Huffmin2(pub u32);
17401 impl Huffmin2 {
17402 #[doc = "HuffMin RAM"]
17403 #[inline(always)]
17404 pub const fn huff_min_ram(&self) -> u32 {
17405 let val = (self.0 >> 0usize) & 0xffff_ffff;
17406 val as u32
17407 }
17408 #[doc = "HuffMin RAM"]
17409 #[inline(always)]
17410 pub fn set_huff_min_ram(&mut self, val: u32) {
17411 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17412 }
17413 }
17414 impl Default for Huffmin2 {
17415 #[inline(always)]
17416 fn default() -> Huffmin2 {
17417 Huffmin2(0)
17418 }
17419 }
17420 impl core::fmt::Debug for Huffmin2 {
17421 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17422 f.debug_struct("Huffmin2")
17423 .field("huff_min_ram", &self.huff_min_ram())
17424 .finish()
17425 }
17426 }
17427 #[cfg(feature = "defmt")]
17428 impl defmt::Format for Huffmin2 {
17429 fn format(&self, f: defmt::Formatter) {
17430 #[derive(defmt :: Format)]
17431 struct Huffmin2 {
17432 huff_min_ram: u32,
17433 }
17434 let proxy = Huffmin2 {
17435 huff_min_ram: self.huff_min_ram(),
17436 };
17437 defmt::write!(f, "{}", proxy)
17438 }
17439 }
17440 #[doc = "JPEG HuffMin tables"]
17441 #[repr(transparent)]
17442 #[derive(Copy, Clone, Eq, PartialEq)]
17443 pub struct Huffmin3(pub u32);
17444 impl Huffmin3 {
17445 #[doc = "HuffMin RAM"]
17446 #[inline(always)]
17447 pub const fn huff_min_ram(&self) -> u32 {
17448 let val = (self.0 >> 0usize) & 0xffff_ffff;
17449 val as u32
17450 }
17451 #[doc = "HuffMin RAM"]
17452 #[inline(always)]
17453 pub fn set_huff_min_ram(&mut self, val: u32) {
17454 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17455 }
17456 }
17457 impl Default for Huffmin3 {
17458 #[inline(always)]
17459 fn default() -> Huffmin3 {
17460 Huffmin3(0)
17461 }
17462 }
17463 impl core::fmt::Debug for Huffmin3 {
17464 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17465 f.debug_struct("Huffmin3")
17466 .field("huff_min_ram", &self.huff_min_ram())
17467 .finish()
17468 }
17469 }
17470 #[cfg(feature = "defmt")]
17471 impl defmt::Format for Huffmin3 {
17472 fn format(&self, f: defmt::Formatter) {
17473 #[derive(defmt :: Format)]
17474 struct Huffmin3 {
17475 huff_min_ram: u32,
17476 }
17477 let proxy = Huffmin3 {
17478 huff_min_ram: self.huff_min_ram(),
17479 };
17480 defmt::write!(f, "{}", proxy)
17481 }
17482 }
17483 #[doc = "JPEG HuffMin tables"]
17484 #[repr(transparent)]
17485 #[derive(Copy, Clone, Eq, PartialEq)]
17486 pub struct Huffmin4(pub u32);
17487 impl Huffmin4 {
17488 #[doc = "HuffMin RAM"]
17489 #[inline(always)]
17490 pub const fn huff_min_ram(&self) -> u32 {
17491 let val = (self.0 >> 0usize) & 0xffff_ffff;
17492 val as u32
17493 }
17494 #[doc = "HuffMin RAM"]
17495 #[inline(always)]
17496 pub fn set_huff_min_ram(&mut self, val: u32) {
17497 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17498 }
17499 }
17500 impl Default for Huffmin4 {
17501 #[inline(always)]
17502 fn default() -> Huffmin4 {
17503 Huffmin4(0)
17504 }
17505 }
17506 impl core::fmt::Debug for Huffmin4 {
17507 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17508 f.debug_struct("Huffmin4")
17509 .field("huff_min_ram", &self.huff_min_ram())
17510 .finish()
17511 }
17512 }
17513 #[cfg(feature = "defmt")]
17514 impl defmt::Format for Huffmin4 {
17515 fn format(&self, f: defmt::Formatter) {
17516 #[derive(defmt :: Format)]
17517 struct Huffmin4 {
17518 huff_min_ram: u32,
17519 }
17520 let proxy = Huffmin4 {
17521 huff_min_ram: self.huff_min_ram(),
17522 };
17523 defmt::write!(f, "{}", proxy)
17524 }
17525 }
17526 #[doc = "JPEG HuffMin tables"]
17527 #[repr(transparent)]
17528 #[derive(Copy, Clone, Eq, PartialEq)]
17529 pub struct Huffmin5(pub u32);
17530 impl Huffmin5 {
17531 #[doc = "HuffMin RAM"]
17532 #[inline(always)]
17533 pub const fn huff_min_ram(&self) -> u32 {
17534 let val = (self.0 >> 0usize) & 0xffff_ffff;
17535 val as u32
17536 }
17537 #[doc = "HuffMin RAM"]
17538 #[inline(always)]
17539 pub fn set_huff_min_ram(&mut self, val: u32) {
17540 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17541 }
17542 }
17543 impl Default for Huffmin5 {
17544 #[inline(always)]
17545 fn default() -> Huffmin5 {
17546 Huffmin5(0)
17547 }
17548 }
17549 impl core::fmt::Debug for Huffmin5 {
17550 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17551 f.debug_struct("Huffmin5")
17552 .field("huff_min_ram", &self.huff_min_ram())
17553 .finish()
17554 }
17555 }
17556 #[cfg(feature = "defmt")]
17557 impl defmt::Format for Huffmin5 {
17558 fn format(&self, f: defmt::Formatter) {
17559 #[derive(defmt :: Format)]
17560 struct Huffmin5 {
17561 huff_min_ram: u32,
17562 }
17563 let proxy = Huffmin5 {
17564 huff_min_ram: self.huff_min_ram(),
17565 };
17566 defmt::write!(f, "{}", proxy)
17567 }
17568 }
17569 #[doc = "JPEG HuffMin tables"]
17570 #[repr(transparent)]
17571 #[derive(Copy, Clone, Eq, PartialEq)]
17572 pub struct Huffmin6(pub u32);
17573 impl Huffmin6 {
17574 #[doc = "HuffMin RAM"]
17575 #[inline(always)]
17576 pub const fn huff_min_ram(&self) -> u32 {
17577 let val = (self.0 >> 0usize) & 0xffff_ffff;
17578 val as u32
17579 }
17580 #[doc = "HuffMin RAM"]
17581 #[inline(always)]
17582 pub fn set_huff_min_ram(&mut self, val: u32) {
17583 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17584 }
17585 }
17586 impl Default for Huffmin6 {
17587 #[inline(always)]
17588 fn default() -> Huffmin6 {
17589 Huffmin6(0)
17590 }
17591 }
17592 impl core::fmt::Debug for Huffmin6 {
17593 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17594 f.debug_struct("Huffmin6")
17595 .field("huff_min_ram", &self.huff_min_ram())
17596 .finish()
17597 }
17598 }
17599 #[cfg(feature = "defmt")]
17600 impl defmt::Format for Huffmin6 {
17601 fn format(&self, f: defmt::Formatter) {
17602 #[derive(defmt :: Format)]
17603 struct Huffmin6 {
17604 huff_min_ram: u32,
17605 }
17606 let proxy = Huffmin6 {
17607 huff_min_ram: self.huff_min_ram(),
17608 };
17609 defmt::write!(f, "{}", proxy)
17610 }
17611 }
17612 #[doc = "JPEG HuffMin tables"]
17613 #[repr(transparent)]
17614 #[derive(Copy, Clone, Eq, PartialEq)]
17615 pub struct Huffmin7(pub u32);
17616 impl Huffmin7 {
17617 #[doc = "HuffMin RAM"]
17618 #[inline(always)]
17619 pub const fn huff_min_ram(&self) -> u32 {
17620 let val = (self.0 >> 0usize) & 0xffff_ffff;
17621 val as u32
17622 }
17623 #[doc = "HuffMin RAM"]
17624 #[inline(always)]
17625 pub fn set_huff_min_ram(&mut self, val: u32) {
17626 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17627 }
17628 }
17629 impl Default for Huffmin7 {
17630 #[inline(always)]
17631 fn default() -> Huffmin7 {
17632 Huffmin7(0)
17633 }
17634 }
17635 impl core::fmt::Debug for Huffmin7 {
17636 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17637 f.debug_struct("Huffmin7")
17638 .field("huff_min_ram", &self.huff_min_ram())
17639 .finish()
17640 }
17641 }
17642 #[cfg(feature = "defmt")]
17643 impl defmt::Format for Huffmin7 {
17644 fn format(&self, f: defmt::Formatter) {
17645 #[derive(defmt :: Format)]
17646 struct Huffmin7 {
17647 huff_min_ram: u32,
17648 }
17649 let proxy = Huffmin7 {
17650 huff_min_ram: self.huff_min_ram(),
17651 };
17652 defmt::write!(f, "{}", proxy)
17653 }
17654 }
17655 #[doc = "JPEG HuffMin tables"]
17656 #[repr(transparent)]
17657 #[derive(Copy, Clone, Eq, PartialEq)]
17658 pub struct Huffmin8(pub u32);
17659 impl Huffmin8 {
17660 #[doc = "HuffMin RAM"]
17661 #[inline(always)]
17662 pub const fn huff_min_ram(&self) -> u32 {
17663 let val = (self.0 >> 0usize) & 0xffff_ffff;
17664 val as u32
17665 }
17666 #[doc = "HuffMin RAM"]
17667 #[inline(always)]
17668 pub fn set_huff_min_ram(&mut self, val: u32) {
17669 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17670 }
17671 }
17672 impl Default for Huffmin8 {
17673 #[inline(always)]
17674 fn default() -> Huffmin8 {
17675 Huffmin8(0)
17676 }
17677 }
17678 impl core::fmt::Debug for Huffmin8 {
17679 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17680 f.debug_struct("Huffmin8")
17681 .field("huff_min_ram", &self.huff_min_ram())
17682 .finish()
17683 }
17684 }
17685 #[cfg(feature = "defmt")]
17686 impl defmt::Format for Huffmin8 {
17687 fn format(&self, f: defmt::Formatter) {
17688 #[derive(defmt :: Format)]
17689 struct Huffmin8 {
17690 huff_min_ram: u32,
17691 }
17692 let proxy = Huffmin8 {
17693 huff_min_ram: self.huff_min_ram(),
17694 };
17695 defmt::write!(f, "{}", proxy)
17696 }
17697 }
17698 #[doc = "JPEG HuffMin tables"]
17699 #[repr(transparent)]
17700 #[derive(Copy, Clone, Eq, PartialEq)]
17701 pub struct Huffmin9(pub u32);
17702 impl Huffmin9 {
17703 #[doc = "HuffMin RAM"]
17704 #[inline(always)]
17705 pub const fn huff_min_ram(&self) -> u32 {
17706 let val = (self.0 >> 0usize) & 0xffff_ffff;
17707 val as u32
17708 }
17709 #[doc = "HuffMin RAM"]
17710 #[inline(always)]
17711 pub fn set_huff_min_ram(&mut self, val: u32) {
17712 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17713 }
17714 }
17715 impl Default for Huffmin9 {
17716 #[inline(always)]
17717 fn default() -> Huffmin9 {
17718 Huffmin9(0)
17719 }
17720 }
17721 impl core::fmt::Debug for Huffmin9 {
17722 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17723 f.debug_struct("Huffmin9")
17724 .field("huff_min_ram", &self.huff_min_ram())
17725 .finish()
17726 }
17727 }
17728 #[cfg(feature = "defmt")]
17729 impl defmt::Format for Huffmin9 {
17730 fn format(&self, f: defmt::Formatter) {
17731 #[derive(defmt :: Format)]
17732 struct Huffmin9 {
17733 huff_min_ram: u32,
17734 }
17735 let proxy = Huffmin9 {
17736 huff_min_ram: self.huff_min_ram(),
17737 };
17738 defmt::write!(f, "{}", proxy)
17739 }
17740 }
17741 #[doc = "JPEG HUFFSYMB tables"]
17742 #[repr(transparent)]
17743 #[derive(Copy, Clone, Eq, PartialEq)]
17744 pub struct Huffsymb0(pub u32);
17745 impl Huffsymb0 {
17746 #[doc = "DHTSymb RAM"]
17747 #[inline(always)]
17748 pub const fn huff_symb_ram(&self) -> u32 {
17749 let val = (self.0 >> 0usize) & 0xffff_ffff;
17750 val as u32
17751 }
17752 #[doc = "DHTSymb RAM"]
17753 #[inline(always)]
17754 pub fn set_huff_symb_ram(&mut self, val: u32) {
17755 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17756 }
17757 }
17758 impl Default for Huffsymb0 {
17759 #[inline(always)]
17760 fn default() -> Huffsymb0 {
17761 Huffsymb0(0)
17762 }
17763 }
17764 impl core::fmt::Debug for Huffsymb0 {
17765 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17766 f.debug_struct("Huffsymb0")
17767 .field("huff_symb_ram", &self.huff_symb_ram())
17768 .finish()
17769 }
17770 }
17771 #[cfg(feature = "defmt")]
17772 impl defmt::Format for Huffsymb0 {
17773 fn format(&self, f: defmt::Formatter) {
17774 #[derive(defmt :: Format)]
17775 struct Huffsymb0 {
17776 huff_symb_ram: u32,
17777 }
17778 let proxy = Huffsymb0 {
17779 huff_symb_ram: self.huff_symb_ram(),
17780 };
17781 defmt::write!(f, "{}", proxy)
17782 }
17783 }
17784 #[doc = "JPEG HUFFSYMB tables"]
17785 #[repr(transparent)]
17786 #[derive(Copy, Clone, Eq, PartialEq)]
17787 pub struct Huffsymb1(pub u32);
17788 impl Huffsymb1 {
17789 #[doc = "DHTSymb RAM"]
17790 #[inline(always)]
17791 pub const fn huff_symb_ram(&self) -> u32 {
17792 let val = (self.0 >> 0usize) & 0xffff_ffff;
17793 val as u32
17794 }
17795 #[doc = "DHTSymb RAM"]
17796 #[inline(always)]
17797 pub fn set_huff_symb_ram(&mut self, val: u32) {
17798 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17799 }
17800 }
17801 impl Default for Huffsymb1 {
17802 #[inline(always)]
17803 fn default() -> Huffsymb1 {
17804 Huffsymb1(0)
17805 }
17806 }
17807 impl core::fmt::Debug for Huffsymb1 {
17808 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17809 f.debug_struct("Huffsymb1")
17810 .field("huff_symb_ram", &self.huff_symb_ram())
17811 .finish()
17812 }
17813 }
17814 #[cfg(feature = "defmt")]
17815 impl defmt::Format for Huffsymb1 {
17816 fn format(&self, f: defmt::Formatter) {
17817 #[derive(defmt :: Format)]
17818 struct Huffsymb1 {
17819 huff_symb_ram: u32,
17820 }
17821 let proxy = Huffsymb1 {
17822 huff_symb_ram: self.huff_symb_ram(),
17823 };
17824 defmt::write!(f, "{}", proxy)
17825 }
17826 }
17827 #[doc = "JPEG HUFFSYMB tables"]
17828 #[repr(transparent)]
17829 #[derive(Copy, Clone, Eq, PartialEq)]
17830 pub struct Huffsymb10(pub u32);
17831 impl Huffsymb10 {
17832 #[doc = "DHTSymb RAM"]
17833 #[inline(always)]
17834 pub const fn huff_symb_ram(&self) -> u32 {
17835 let val = (self.0 >> 0usize) & 0xffff_ffff;
17836 val as u32
17837 }
17838 #[doc = "DHTSymb RAM"]
17839 #[inline(always)]
17840 pub fn set_huff_symb_ram(&mut self, val: u32) {
17841 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17842 }
17843 }
17844 impl Default for Huffsymb10 {
17845 #[inline(always)]
17846 fn default() -> Huffsymb10 {
17847 Huffsymb10(0)
17848 }
17849 }
17850 impl core::fmt::Debug for Huffsymb10 {
17851 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17852 f.debug_struct("Huffsymb10")
17853 .field("huff_symb_ram", &self.huff_symb_ram())
17854 .finish()
17855 }
17856 }
17857 #[cfg(feature = "defmt")]
17858 impl defmt::Format for Huffsymb10 {
17859 fn format(&self, f: defmt::Formatter) {
17860 #[derive(defmt :: Format)]
17861 struct Huffsymb10 {
17862 huff_symb_ram: u32,
17863 }
17864 let proxy = Huffsymb10 {
17865 huff_symb_ram: self.huff_symb_ram(),
17866 };
17867 defmt::write!(f, "{}", proxy)
17868 }
17869 }
17870 #[doc = "JPEG HUFFSYMB tables"]
17871 #[repr(transparent)]
17872 #[derive(Copy, Clone, Eq, PartialEq)]
17873 pub struct Huffsymb11(pub u32);
17874 impl Huffsymb11 {
17875 #[doc = "DHTSymb RAM"]
17876 #[inline(always)]
17877 pub const fn huff_symb_ram(&self) -> u32 {
17878 let val = (self.0 >> 0usize) & 0xffff_ffff;
17879 val as u32
17880 }
17881 #[doc = "DHTSymb RAM"]
17882 #[inline(always)]
17883 pub fn set_huff_symb_ram(&mut self, val: u32) {
17884 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17885 }
17886 }
17887 impl Default for Huffsymb11 {
17888 #[inline(always)]
17889 fn default() -> Huffsymb11 {
17890 Huffsymb11(0)
17891 }
17892 }
17893 impl core::fmt::Debug for Huffsymb11 {
17894 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17895 f.debug_struct("Huffsymb11")
17896 .field("huff_symb_ram", &self.huff_symb_ram())
17897 .finish()
17898 }
17899 }
17900 #[cfg(feature = "defmt")]
17901 impl defmt::Format for Huffsymb11 {
17902 fn format(&self, f: defmt::Formatter) {
17903 #[derive(defmt :: Format)]
17904 struct Huffsymb11 {
17905 huff_symb_ram: u32,
17906 }
17907 let proxy = Huffsymb11 {
17908 huff_symb_ram: self.huff_symb_ram(),
17909 };
17910 defmt::write!(f, "{}", proxy)
17911 }
17912 }
17913 #[doc = "JPEG HUFFSYMB tables"]
17914 #[repr(transparent)]
17915 #[derive(Copy, Clone, Eq, PartialEq)]
17916 pub struct Huffsymb12(pub u32);
17917 impl Huffsymb12 {
17918 #[doc = "DHTSymb RAM"]
17919 #[inline(always)]
17920 pub const fn huff_symb_ram(&self) -> u32 {
17921 let val = (self.0 >> 0usize) & 0xffff_ffff;
17922 val as u32
17923 }
17924 #[doc = "DHTSymb RAM"]
17925 #[inline(always)]
17926 pub fn set_huff_symb_ram(&mut self, val: u32) {
17927 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17928 }
17929 }
17930 impl Default for Huffsymb12 {
17931 #[inline(always)]
17932 fn default() -> Huffsymb12 {
17933 Huffsymb12(0)
17934 }
17935 }
17936 impl core::fmt::Debug for Huffsymb12 {
17937 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17938 f.debug_struct("Huffsymb12")
17939 .field("huff_symb_ram", &self.huff_symb_ram())
17940 .finish()
17941 }
17942 }
17943 #[cfg(feature = "defmt")]
17944 impl defmt::Format for Huffsymb12 {
17945 fn format(&self, f: defmt::Formatter) {
17946 #[derive(defmt :: Format)]
17947 struct Huffsymb12 {
17948 huff_symb_ram: u32,
17949 }
17950 let proxy = Huffsymb12 {
17951 huff_symb_ram: self.huff_symb_ram(),
17952 };
17953 defmt::write!(f, "{}", proxy)
17954 }
17955 }
17956 #[doc = "JPEG HUFFSYMB tables"]
17957 #[repr(transparent)]
17958 #[derive(Copy, Clone, Eq, PartialEq)]
17959 pub struct Huffsymb13(pub u32);
17960 impl Huffsymb13 {
17961 #[doc = "DHTSymb RAM"]
17962 #[inline(always)]
17963 pub const fn huff_symb_ram(&self) -> u32 {
17964 let val = (self.0 >> 0usize) & 0xffff_ffff;
17965 val as u32
17966 }
17967 #[doc = "DHTSymb RAM"]
17968 #[inline(always)]
17969 pub fn set_huff_symb_ram(&mut self, val: u32) {
17970 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
17971 }
17972 }
17973 impl Default for Huffsymb13 {
17974 #[inline(always)]
17975 fn default() -> Huffsymb13 {
17976 Huffsymb13(0)
17977 }
17978 }
17979 impl core::fmt::Debug for Huffsymb13 {
17980 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
17981 f.debug_struct("Huffsymb13")
17982 .field("huff_symb_ram", &self.huff_symb_ram())
17983 .finish()
17984 }
17985 }
17986 #[cfg(feature = "defmt")]
17987 impl defmt::Format for Huffsymb13 {
17988 fn format(&self, f: defmt::Formatter) {
17989 #[derive(defmt :: Format)]
17990 struct Huffsymb13 {
17991 huff_symb_ram: u32,
17992 }
17993 let proxy = Huffsymb13 {
17994 huff_symb_ram: self.huff_symb_ram(),
17995 };
17996 defmt::write!(f, "{}", proxy)
17997 }
17998 }
17999 #[doc = "JPEG HUFFSYMB tables"]
18000 #[repr(transparent)]
18001 #[derive(Copy, Clone, Eq, PartialEq)]
18002 pub struct Huffsymb14(pub u32);
18003 impl Huffsymb14 {
18004 #[doc = "DHTSymb RAM"]
18005 #[inline(always)]
18006 pub const fn huff_symb_ram(&self) -> u32 {
18007 let val = (self.0 >> 0usize) & 0xffff_ffff;
18008 val as u32
18009 }
18010 #[doc = "DHTSymb RAM"]
18011 #[inline(always)]
18012 pub fn set_huff_symb_ram(&mut self, val: u32) {
18013 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18014 }
18015 }
18016 impl Default for Huffsymb14 {
18017 #[inline(always)]
18018 fn default() -> Huffsymb14 {
18019 Huffsymb14(0)
18020 }
18021 }
18022 impl core::fmt::Debug for Huffsymb14 {
18023 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18024 f.debug_struct("Huffsymb14")
18025 .field("huff_symb_ram", &self.huff_symb_ram())
18026 .finish()
18027 }
18028 }
18029 #[cfg(feature = "defmt")]
18030 impl defmt::Format for Huffsymb14 {
18031 fn format(&self, f: defmt::Formatter) {
18032 #[derive(defmt :: Format)]
18033 struct Huffsymb14 {
18034 huff_symb_ram: u32,
18035 }
18036 let proxy = Huffsymb14 {
18037 huff_symb_ram: self.huff_symb_ram(),
18038 };
18039 defmt::write!(f, "{}", proxy)
18040 }
18041 }
18042 #[doc = "JPEG HUFFSYMB tables"]
18043 #[repr(transparent)]
18044 #[derive(Copy, Clone, Eq, PartialEq)]
18045 pub struct Huffsymb15(pub u32);
18046 impl Huffsymb15 {
18047 #[doc = "DHTSymb RAM"]
18048 #[inline(always)]
18049 pub const fn huff_symb_ram(&self) -> u32 {
18050 let val = (self.0 >> 0usize) & 0xffff_ffff;
18051 val as u32
18052 }
18053 #[doc = "DHTSymb RAM"]
18054 #[inline(always)]
18055 pub fn set_huff_symb_ram(&mut self, val: u32) {
18056 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18057 }
18058 }
18059 impl Default for Huffsymb15 {
18060 #[inline(always)]
18061 fn default() -> Huffsymb15 {
18062 Huffsymb15(0)
18063 }
18064 }
18065 impl core::fmt::Debug for Huffsymb15 {
18066 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18067 f.debug_struct("Huffsymb15")
18068 .field("huff_symb_ram", &self.huff_symb_ram())
18069 .finish()
18070 }
18071 }
18072 #[cfg(feature = "defmt")]
18073 impl defmt::Format for Huffsymb15 {
18074 fn format(&self, f: defmt::Formatter) {
18075 #[derive(defmt :: Format)]
18076 struct Huffsymb15 {
18077 huff_symb_ram: u32,
18078 }
18079 let proxy = Huffsymb15 {
18080 huff_symb_ram: self.huff_symb_ram(),
18081 };
18082 defmt::write!(f, "{}", proxy)
18083 }
18084 }
18085 #[doc = "JPEG HUFFSYMB tables"]
18086 #[repr(transparent)]
18087 #[derive(Copy, Clone, Eq, PartialEq)]
18088 pub struct Huffsymb16(pub u32);
18089 impl Huffsymb16 {
18090 #[doc = "DHTSymb RAM"]
18091 #[inline(always)]
18092 pub const fn huff_symb_ram(&self) -> u32 {
18093 let val = (self.0 >> 0usize) & 0xffff_ffff;
18094 val as u32
18095 }
18096 #[doc = "DHTSymb RAM"]
18097 #[inline(always)]
18098 pub fn set_huff_symb_ram(&mut self, val: u32) {
18099 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18100 }
18101 }
18102 impl Default for Huffsymb16 {
18103 #[inline(always)]
18104 fn default() -> Huffsymb16 {
18105 Huffsymb16(0)
18106 }
18107 }
18108 impl core::fmt::Debug for Huffsymb16 {
18109 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18110 f.debug_struct("Huffsymb16")
18111 .field("huff_symb_ram", &self.huff_symb_ram())
18112 .finish()
18113 }
18114 }
18115 #[cfg(feature = "defmt")]
18116 impl defmt::Format for Huffsymb16 {
18117 fn format(&self, f: defmt::Formatter) {
18118 #[derive(defmt :: Format)]
18119 struct Huffsymb16 {
18120 huff_symb_ram: u32,
18121 }
18122 let proxy = Huffsymb16 {
18123 huff_symb_ram: self.huff_symb_ram(),
18124 };
18125 defmt::write!(f, "{}", proxy)
18126 }
18127 }
18128 #[doc = "JPEG HUFFSYMB tables"]
18129 #[repr(transparent)]
18130 #[derive(Copy, Clone, Eq, PartialEq)]
18131 pub struct Huffsymb17(pub u32);
18132 impl Huffsymb17 {
18133 #[doc = "DHTSymb RAM"]
18134 #[inline(always)]
18135 pub const fn huff_symb_ram(&self) -> u32 {
18136 let val = (self.0 >> 0usize) & 0xffff_ffff;
18137 val as u32
18138 }
18139 #[doc = "DHTSymb RAM"]
18140 #[inline(always)]
18141 pub fn set_huff_symb_ram(&mut self, val: u32) {
18142 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18143 }
18144 }
18145 impl Default for Huffsymb17 {
18146 #[inline(always)]
18147 fn default() -> Huffsymb17 {
18148 Huffsymb17(0)
18149 }
18150 }
18151 impl core::fmt::Debug for Huffsymb17 {
18152 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18153 f.debug_struct("Huffsymb17")
18154 .field("huff_symb_ram", &self.huff_symb_ram())
18155 .finish()
18156 }
18157 }
18158 #[cfg(feature = "defmt")]
18159 impl defmt::Format for Huffsymb17 {
18160 fn format(&self, f: defmt::Formatter) {
18161 #[derive(defmt :: Format)]
18162 struct Huffsymb17 {
18163 huff_symb_ram: u32,
18164 }
18165 let proxy = Huffsymb17 {
18166 huff_symb_ram: self.huff_symb_ram(),
18167 };
18168 defmt::write!(f, "{}", proxy)
18169 }
18170 }
18171 #[doc = "JPEG HUFFSYMB tables"]
18172 #[repr(transparent)]
18173 #[derive(Copy, Clone, Eq, PartialEq)]
18174 pub struct Huffsymb18(pub u32);
18175 impl Huffsymb18 {
18176 #[doc = "DHTSymb RAM"]
18177 #[inline(always)]
18178 pub const fn huff_symb_ram(&self) -> u32 {
18179 let val = (self.0 >> 0usize) & 0xffff_ffff;
18180 val as u32
18181 }
18182 #[doc = "DHTSymb RAM"]
18183 #[inline(always)]
18184 pub fn set_huff_symb_ram(&mut self, val: u32) {
18185 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18186 }
18187 }
18188 impl Default for Huffsymb18 {
18189 #[inline(always)]
18190 fn default() -> Huffsymb18 {
18191 Huffsymb18(0)
18192 }
18193 }
18194 impl core::fmt::Debug for Huffsymb18 {
18195 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18196 f.debug_struct("Huffsymb18")
18197 .field("huff_symb_ram", &self.huff_symb_ram())
18198 .finish()
18199 }
18200 }
18201 #[cfg(feature = "defmt")]
18202 impl defmt::Format for Huffsymb18 {
18203 fn format(&self, f: defmt::Formatter) {
18204 #[derive(defmt :: Format)]
18205 struct Huffsymb18 {
18206 huff_symb_ram: u32,
18207 }
18208 let proxy = Huffsymb18 {
18209 huff_symb_ram: self.huff_symb_ram(),
18210 };
18211 defmt::write!(f, "{}", proxy)
18212 }
18213 }
18214 #[doc = "JPEG HUFFSYMB tables"]
18215 #[repr(transparent)]
18216 #[derive(Copy, Clone, Eq, PartialEq)]
18217 pub struct Huffsymb19(pub u32);
18218 impl Huffsymb19 {
18219 #[doc = "DHTSymb RAM"]
18220 #[inline(always)]
18221 pub const fn huff_symb_ram(&self) -> u32 {
18222 let val = (self.0 >> 0usize) & 0xffff_ffff;
18223 val as u32
18224 }
18225 #[doc = "DHTSymb RAM"]
18226 #[inline(always)]
18227 pub fn set_huff_symb_ram(&mut self, val: u32) {
18228 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18229 }
18230 }
18231 impl Default for Huffsymb19 {
18232 #[inline(always)]
18233 fn default() -> Huffsymb19 {
18234 Huffsymb19(0)
18235 }
18236 }
18237 impl core::fmt::Debug for Huffsymb19 {
18238 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18239 f.debug_struct("Huffsymb19")
18240 .field("huff_symb_ram", &self.huff_symb_ram())
18241 .finish()
18242 }
18243 }
18244 #[cfg(feature = "defmt")]
18245 impl defmt::Format for Huffsymb19 {
18246 fn format(&self, f: defmt::Formatter) {
18247 #[derive(defmt :: Format)]
18248 struct Huffsymb19 {
18249 huff_symb_ram: u32,
18250 }
18251 let proxy = Huffsymb19 {
18252 huff_symb_ram: self.huff_symb_ram(),
18253 };
18254 defmt::write!(f, "{}", proxy)
18255 }
18256 }
18257 #[doc = "JPEG HUFFSYMB tables"]
18258 #[repr(transparent)]
18259 #[derive(Copy, Clone, Eq, PartialEq)]
18260 pub struct Huffsymb2(pub u32);
18261 impl Huffsymb2 {
18262 #[doc = "DHTSymb RAM"]
18263 #[inline(always)]
18264 pub const fn huff_symb_ram(&self) -> u32 {
18265 let val = (self.0 >> 0usize) & 0xffff_ffff;
18266 val as u32
18267 }
18268 #[doc = "DHTSymb RAM"]
18269 #[inline(always)]
18270 pub fn set_huff_symb_ram(&mut self, val: u32) {
18271 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18272 }
18273 }
18274 impl Default for Huffsymb2 {
18275 #[inline(always)]
18276 fn default() -> Huffsymb2 {
18277 Huffsymb2(0)
18278 }
18279 }
18280 impl core::fmt::Debug for Huffsymb2 {
18281 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18282 f.debug_struct("Huffsymb2")
18283 .field("huff_symb_ram", &self.huff_symb_ram())
18284 .finish()
18285 }
18286 }
18287 #[cfg(feature = "defmt")]
18288 impl defmt::Format for Huffsymb2 {
18289 fn format(&self, f: defmt::Formatter) {
18290 #[derive(defmt :: Format)]
18291 struct Huffsymb2 {
18292 huff_symb_ram: u32,
18293 }
18294 let proxy = Huffsymb2 {
18295 huff_symb_ram: self.huff_symb_ram(),
18296 };
18297 defmt::write!(f, "{}", proxy)
18298 }
18299 }
18300 #[doc = "JPEG HUFFSYMB tables"]
18301 #[repr(transparent)]
18302 #[derive(Copy, Clone, Eq, PartialEq)]
18303 pub struct Huffsymb20(pub u32);
18304 impl Huffsymb20 {
18305 #[doc = "DHTSymb RAM"]
18306 #[inline(always)]
18307 pub const fn huff_symb_ram(&self) -> u32 {
18308 let val = (self.0 >> 0usize) & 0xffff_ffff;
18309 val as u32
18310 }
18311 #[doc = "DHTSymb RAM"]
18312 #[inline(always)]
18313 pub fn set_huff_symb_ram(&mut self, val: u32) {
18314 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18315 }
18316 }
18317 impl Default for Huffsymb20 {
18318 #[inline(always)]
18319 fn default() -> Huffsymb20 {
18320 Huffsymb20(0)
18321 }
18322 }
18323 impl core::fmt::Debug for Huffsymb20 {
18324 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18325 f.debug_struct("Huffsymb20")
18326 .field("huff_symb_ram", &self.huff_symb_ram())
18327 .finish()
18328 }
18329 }
18330 #[cfg(feature = "defmt")]
18331 impl defmt::Format for Huffsymb20 {
18332 fn format(&self, f: defmt::Formatter) {
18333 #[derive(defmt :: Format)]
18334 struct Huffsymb20 {
18335 huff_symb_ram: u32,
18336 }
18337 let proxy = Huffsymb20 {
18338 huff_symb_ram: self.huff_symb_ram(),
18339 };
18340 defmt::write!(f, "{}", proxy)
18341 }
18342 }
18343 #[doc = "JPEG HUFFSYMB tables"]
18344 #[repr(transparent)]
18345 #[derive(Copy, Clone, Eq, PartialEq)]
18346 pub struct Huffsymb21(pub u32);
18347 impl Huffsymb21 {
18348 #[doc = "DHTSymb RAM"]
18349 #[inline(always)]
18350 pub const fn huff_symb_ram(&self) -> u32 {
18351 let val = (self.0 >> 0usize) & 0xffff_ffff;
18352 val as u32
18353 }
18354 #[doc = "DHTSymb RAM"]
18355 #[inline(always)]
18356 pub fn set_huff_symb_ram(&mut self, val: u32) {
18357 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18358 }
18359 }
18360 impl Default for Huffsymb21 {
18361 #[inline(always)]
18362 fn default() -> Huffsymb21 {
18363 Huffsymb21(0)
18364 }
18365 }
18366 impl core::fmt::Debug for Huffsymb21 {
18367 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18368 f.debug_struct("Huffsymb21")
18369 .field("huff_symb_ram", &self.huff_symb_ram())
18370 .finish()
18371 }
18372 }
18373 #[cfg(feature = "defmt")]
18374 impl defmt::Format for Huffsymb21 {
18375 fn format(&self, f: defmt::Formatter) {
18376 #[derive(defmt :: Format)]
18377 struct Huffsymb21 {
18378 huff_symb_ram: u32,
18379 }
18380 let proxy = Huffsymb21 {
18381 huff_symb_ram: self.huff_symb_ram(),
18382 };
18383 defmt::write!(f, "{}", proxy)
18384 }
18385 }
18386 #[doc = "JPEG HUFFSYMB tables"]
18387 #[repr(transparent)]
18388 #[derive(Copy, Clone, Eq, PartialEq)]
18389 pub struct Huffsymb22(pub u32);
18390 impl Huffsymb22 {
18391 #[doc = "DHTSymb RAM"]
18392 #[inline(always)]
18393 pub const fn huff_symb_ram(&self) -> u32 {
18394 let val = (self.0 >> 0usize) & 0xffff_ffff;
18395 val as u32
18396 }
18397 #[doc = "DHTSymb RAM"]
18398 #[inline(always)]
18399 pub fn set_huff_symb_ram(&mut self, val: u32) {
18400 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18401 }
18402 }
18403 impl Default for Huffsymb22 {
18404 #[inline(always)]
18405 fn default() -> Huffsymb22 {
18406 Huffsymb22(0)
18407 }
18408 }
18409 impl core::fmt::Debug for Huffsymb22 {
18410 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18411 f.debug_struct("Huffsymb22")
18412 .field("huff_symb_ram", &self.huff_symb_ram())
18413 .finish()
18414 }
18415 }
18416 #[cfg(feature = "defmt")]
18417 impl defmt::Format for Huffsymb22 {
18418 fn format(&self, f: defmt::Formatter) {
18419 #[derive(defmt :: Format)]
18420 struct Huffsymb22 {
18421 huff_symb_ram: u32,
18422 }
18423 let proxy = Huffsymb22 {
18424 huff_symb_ram: self.huff_symb_ram(),
18425 };
18426 defmt::write!(f, "{}", proxy)
18427 }
18428 }
18429 #[doc = "JPEG HUFFSYMB tables"]
18430 #[repr(transparent)]
18431 #[derive(Copy, Clone, Eq, PartialEq)]
18432 pub struct Huffsymb23(pub u32);
18433 impl Huffsymb23 {
18434 #[doc = "DHTSymb RAM"]
18435 #[inline(always)]
18436 pub const fn huff_symb_ram(&self) -> u32 {
18437 let val = (self.0 >> 0usize) & 0xffff_ffff;
18438 val as u32
18439 }
18440 #[doc = "DHTSymb RAM"]
18441 #[inline(always)]
18442 pub fn set_huff_symb_ram(&mut self, val: u32) {
18443 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18444 }
18445 }
18446 impl Default for Huffsymb23 {
18447 #[inline(always)]
18448 fn default() -> Huffsymb23 {
18449 Huffsymb23(0)
18450 }
18451 }
18452 impl core::fmt::Debug for Huffsymb23 {
18453 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18454 f.debug_struct("Huffsymb23")
18455 .field("huff_symb_ram", &self.huff_symb_ram())
18456 .finish()
18457 }
18458 }
18459 #[cfg(feature = "defmt")]
18460 impl defmt::Format for Huffsymb23 {
18461 fn format(&self, f: defmt::Formatter) {
18462 #[derive(defmt :: Format)]
18463 struct Huffsymb23 {
18464 huff_symb_ram: u32,
18465 }
18466 let proxy = Huffsymb23 {
18467 huff_symb_ram: self.huff_symb_ram(),
18468 };
18469 defmt::write!(f, "{}", proxy)
18470 }
18471 }
18472 #[doc = "JPEG HUFFSYMB tables"]
18473 #[repr(transparent)]
18474 #[derive(Copy, Clone, Eq, PartialEq)]
18475 pub struct Huffsymb24(pub u32);
18476 impl Huffsymb24 {
18477 #[doc = "DHTSymb RAM"]
18478 #[inline(always)]
18479 pub const fn huff_symb_ram(&self) -> u32 {
18480 let val = (self.0 >> 0usize) & 0xffff_ffff;
18481 val as u32
18482 }
18483 #[doc = "DHTSymb RAM"]
18484 #[inline(always)]
18485 pub fn set_huff_symb_ram(&mut self, val: u32) {
18486 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18487 }
18488 }
18489 impl Default for Huffsymb24 {
18490 #[inline(always)]
18491 fn default() -> Huffsymb24 {
18492 Huffsymb24(0)
18493 }
18494 }
18495 impl core::fmt::Debug for Huffsymb24 {
18496 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18497 f.debug_struct("Huffsymb24")
18498 .field("huff_symb_ram", &self.huff_symb_ram())
18499 .finish()
18500 }
18501 }
18502 #[cfg(feature = "defmt")]
18503 impl defmt::Format for Huffsymb24 {
18504 fn format(&self, f: defmt::Formatter) {
18505 #[derive(defmt :: Format)]
18506 struct Huffsymb24 {
18507 huff_symb_ram: u32,
18508 }
18509 let proxy = Huffsymb24 {
18510 huff_symb_ram: self.huff_symb_ram(),
18511 };
18512 defmt::write!(f, "{}", proxy)
18513 }
18514 }
18515 #[doc = "JPEG HUFFSYMB tables"]
18516 #[repr(transparent)]
18517 #[derive(Copy, Clone, Eq, PartialEq)]
18518 pub struct Huffsymb25(pub u32);
18519 impl Huffsymb25 {
18520 #[doc = "DHTSymb RAM"]
18521 #[inline(always)]
18522 pub const fn huff_symb_ram(&self) -> u32 {
18523 let val = (self.0 >> 0usize) & 0xffff_ffff;
18524 val as u32
18525 }
18526 #[doc = "DHTSymb RAM"]
18527 #[inline(always)]
18528 pub fn set_huff_symb_ram(&mut self, val: u32) {
18529 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18530 }
18531 }
18532 impl Default for Huffsymb25 {
18533 #[inline(always)]
18534 fn default() -> Huffsymb25 {
18535 Huffsymb25(0)
18536 }
18537 }
18538 impl core::fmt::Debug for Huffsymb25 {
18539 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18540 f.debug_struct("Huffsymb25")
18541 .field("huff_symb_ram", &self.huff_symb_ram())
18542 .finish()
18543 }
18544 }
18545 #[cfg(feature = "defmt")]
18546 impl defmt::Format for Huffsymb25 {
18547 fn format(&self, f: defmt::Formatter) {
18548 #[derive(defmt :: Format)]
18549 struct Huffsymb25 {
18550 huff_symb_ram: u32,
18551 }
18552 let proxy = Huffsymb25 {
18553 huff_symb_ram: self.huff_symb_ram(),
18554 };
18555 defmt::write!(f, "{}", proxy)
18556 }
18557 }
18558 #[doc = "JPEG HUFFSYMB tables"]
18559 #[repr(transparent)]
18560 #[derive(Copy, Clone, Eq, PartialEq)]
18561 pub struct Huffsymb26(pub u32);
18562 impl Huffsymb26 {
18563 #[doc = "DHTSymb RAM"]
18564 #[inline(always)]
18565 pub const fn huff_symb_ram(&self) -> u32 {
18566 let val = (self.0 >> 0usize) & 0xffff_ffff;
18567 val as u32
18568 }
18569 #[doc = "DHTSymb RAM"]
18570 #[inline(always)]
18571 pub fn set_huff_symb_ram(&mut self, val: u32) {
18572 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18573 }
18574 }
18575 impl Default for Huffsymb26 {
18576 #[inline(always)]
18577 fn default() -> Huffsymb26 {
18578 Huffsymb26(0)
18579 }
18580 }
18581 impl core::fmt::Debug for Huffsymb26 {
18582 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18583 f.debug_struct("Huffsymb26")
18584 .field("huff_symb_ram", &self.huff_symb_ram())
18585 .finish()
18586 }
18587 }
18588 #[cfg(feature = "defmt")]
18589 impl defmt::Format for Huffsymb26 {
18590 fn format(&self, f: defmt::Formatter) {
18591 #[derive(defmt :: Format)]
18592 struct Huffsymb26 {
18593 huff_symb_ram: u32,
18594 }
18595 let proxy = Huffsymb26 {
18596 huff_symb_ram: self.huff_symb_ram(),
18597 };
18598 defmt::write!(f, "{}", proxy)
18599 }
18600 }
18601 #[doc = "JPEG HUFFSYMB tables"]
18602 #[repr(transparent)]
18603 #[derive(Copy, Clone, Eq, PartialEq)]
18604 pub struct Huffsymb27(pub u32);
18605 impl Huffsymb27 {
18606 #[doc = "DHTSymb RAM"]
18607 #[inline(always)]
18608 pub const fn huff_symb_ram(&self) -> u32 {
18609 let val = (self.0 >> 0usize) & 0xffff_ffff;
18610 val as u32
18611 }
18612 #[doc = "DHTSymb RAM"]
18613 #[inline(always)]
18614 pub fn set_huff_symb_ram(&mut self, val: u32) {
18615 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18616 }
18617 }
18618 impl Default for Huffsymb27 {
18619 #[inline(always)]
18620 fn default() -> Huffsymb27 {
18621 Huffsymb27(0)
18622 }
18623 }
18624 impl core::fmt::Debug for Huffsymb27 {
18625 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18626 f.debug_struct("Huffsymb27")
18627 .field("huff_symb_ram", &self.huff_symb_ram())
18628 .finish()
18629 }
18630 }
18631 #[cfg(feature = "defmt")]
18632 impl defmt::Format for Huffsymb27 {
18633 fn format(&self, f: defmt::Formatter) {
18634 #[derive(defmt :: Format)]
18635 struct Huffsymb27 {
18636 huff_symb_ram: u32,
18637 }
18638 let proxy = Huffsymb27 {
18639 huff_symb_ram: self.huff_symb_ram(),
18640 };
18641 defmt::write!(f, "{}", proxy)
18642 }
18643 }
18644 #[doc = "JPEG HUFFSYMB tables"]
18645 #[repr(transparent)]
18646 #[derive(Copy, Clone, Eq, PartialEq)]
18647 pub struct Huffsymb28(pub u32);
18648 impl Huffsymb28 {
18649 #[doc = "DHTSymb RAM"]
18650 #[inline(always)]
18651 pub const fn huff_symb_ram(&self) -> u32 {
18652 let val = (self.0 >> 0usize) & 0xffff_ffff;
18653 val as u32
18654 }
18655 #[doc = "DHTSymb RAM"]
18656 #[inline(always)]
18657 pub fn set_huff_symb_ram(&mut self, val: u32) {
18658 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18659 }
18660 }
18661 impl Default for Huffsymb28 {
18662 #[inline(always)]
18663 fn default() -> Huffsymb28 {
18664 Huffsymb28(0)
18665 }
18666 }
18667 impl core::fmt::Debug for Huffsymb28 {
18668 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18669 f.debug_struct("Huffsymb28")
18670 .field("huff_symb_ram", &self.huff_symb_ram())
18671 .finish()
18672 }
18673 }
18674 #[cfg(feature = "defmt")]
18675 impl defmt::Format for Huffsymb28 {
18676 fn format(&self, f: defmt::Formatter) {
18677 #[derive(defmt :: Format)]
18678 struct Huffsymb28 {
18679 huff_symb_ram: u32,
18680 }
18681 let proxy = Huffsymb28 {
18682 huff_symb_ram: self.huff_symb_ram(),
18683 };
18684 defmt::write!(f, "{}", proxy)
18685 }
18686 }
18687 #[doc = "JPEG HUFFSYMB tables"]
18688 #[repr(transparent)]
18689 #[derive(Copy, Clone, Eq, PartialEq)]
18690 pub struct Huffsymb29(pub u32);
18691 impl Huffsymb29 {
18692 #[doc = "DHTSymb RAM"]
18693 #[inline(always)]
18694 pub const fn huff_symb_ram(&self) -> u32 {
18695 let val = (self.0 >> 0usize) & 0xffff_ffff;
18696 val as u32
18697 }
18698 #[doc = "DHTSymb RAM"]
18699 #[inline(always)]
18700 pub fn set_huff_symb_ram(&mut self, val: u32) {
18701 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18702 }
18703 }
18704 impl Default for Huffsymb29 {
18705 #[inline(always)]
18706 fn default() -> Huffsymb29 {
18707 Huffsymb29(0)
18708 }
18709 }
18710 impl core::fmt::Debug for Huffsymb29 {
18711 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18712 f.debug_struct("Huffsymb29")
18713 .field("huff_symb_ram", &self.huff_symb_ram())
18714 .finish()
18715 }
18716 }
18717 #[cfg(feature = "defmt")]
18718 impl defmt::Format for Huffsymb29 {
18719 fn format(&self, f: defmt::Formatter) {
18720 #[derive(defmt :: Format)]
18721 struct Huffsymb29 {
18722 huff_symb_ram: u32,
18723 }
18724 let proxy = Huffsymb29 {
18725 huff_symb_ram: self.huff_symb_ram(),
18726 };
18727 defmt::write!(f, "{}", proxy)
18728 }
18729 }
18730 #[doc = "JPEG HUFFSYMB tables"]
18731 #[repr(transparent)]
18732 #[derive(Copy, Clone, Eq, PartialEq)]
18733 pub struct Huffsymb3(pub u32);
18734 impl Huffsymb3 {
18735 #[doc = "DHTSymb RAM"]
18736 #[inline(always)]
18737 pub const fn huff_symb_ram(&self) -> u32 {
18738 let val = (self.0 >> 0usize) & 0xffff_ffff;
18739 val as u32
18740 }
18741 #[doc = "DHTSymb RAM"]
18742 #[inline(always)]
18743 pub fn set_huff_symb_ram(&mut self, val: u32) {
18744 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18745 }
18746 }
18747 impl Default for Huffsymb3 {
18748 #[inline(always)]
18749 fn default() -> Huffsymb3 {
18750 Huffsymb3(0)
18751 }
18752 }
18753 impl core::fmt::Debug for Huffsymb3 {
18754 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18755 f.debug_struct("Huffsymb3")
18756 .field("huff_symb_ram", &self.huff_symb_ram())
18757 .finish()
18758 }
18759 }
18760 #[cfg(feature = "defmt")]
18761 impl defmt::Format for Huffsymb3 {
18762 fn format(&self, f: defmt::Formatter) {
18763 #[derive(defmt :: Format)]
18764 struct Huffsymb3 {
18765 huff_symb_ram: u32,
18766 }
18767 let proxy = Huffsymb3 {
18768 huff_symb_ram: self.huff_symb_ram(),
18769 };
18770 defmt::write!(f, "{}", proxy)
18771 }
18772 }
18773 #[doc = "JPEG HUFFSYMB tables"]
18774 #[repr(transparent)]
18775 #[derive(Copy, Clone, Eq, PartialEq)]
18776 pub struct Huffsymb30(pub u32);
18777 impl Huffsymb30 {
18778 #[doc = "DHTSymb RAM"]
18779 #[inline(always)]
18780 pub const fn huff_symb_ram(&self) -> u32 {
18781 let val = (self.0 >> 0usize) & 0xffff_ffff;
18782 val as u32
18783 }
18784 #[doc = "DHTSymb RAM"]
18785 #[inline(always)]
18786 pub fn set_huff_symb_ram(&mut self, val: u32) {
18787 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18788 }
18789 }
18790 impl Default for Huffsymb30 {
18791 #[inline(always)]
18792 fn default() -> Huffsymb30 {
18793 Huffsymb30(0)
18794 }
18795 }
18796 impl core::fmt::Debug for Huffsymb30 {
18797 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18798 f.debug_struct("Huffsymb30")
18799 .field("huff_symb_ram", &self.huff_symb_ram())
18800 .finish()
18801 }
18802 }
18803 #[cfg(feature = "defmt")]
18804 impl defmt::Format for Huffsymb30 {
18805 fn format(&self, f: defmt::Formatter) {
18806 #[derive(defmt :: Format)]
18807 struct Huffsymb30 {
18808 huff_symb_ram: u32,
18809 }
18810 let proxy = Huffsymb30 {
18811 huff_symb_ram: self.huff_symb_ram(),
18812 };
18813 defmt::write!(f, "{}", proxy)
18814 }
18815 }
18816 #[doc = "JPEG HUFFSYMB tables"]
18817 #[repr(transparent)]
18818 #[derive(Copy, Clone, Eq, PartialEq)]
18819 pub struct Huffsymb31(pub u32);
18820 impl Huffsymb31 {
18821 #[doc = "DHTSymb RAM"]
18822 #[inline(always)]
18823 pub const fn huff_symb_ram(&self) -> u32 {
18824 let val = (self.0 >> 0usize) & 0xffff_ffff;
18825 val as u32
18826 }
18827 #[doc = "DHTSymb RAM"]
18828 #[inline(always)]
18829 pub fn set_huff_symb_ram(&mut self, val: u32) {
18830 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18831 }
18832 }
18833 impl Default for Huffsymb31 {
18834 #[inline(always)]
18835 fn default() -> Huffsymb31 {
18836 Huffsymb31(0)
18837 }
18838 }
18839 impl core::fmt::Debug for Huffsymb31 {
18840 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18841 f.debug_struct("Huffsymb31")
18842 .field("huff_symb_ram", &self.huff_symb_ram())
18843 .finish()
18844 }
18845 }
18846 #[cfg(feature = "defmt")]
18847 impl defmt::Format for Huffsymb31 {
18848 fn format(&self, f: defmt::Formatter) {
18849 #[derive(defmt :: Format)]
18850 struct Huffsymb31 {
18851 huff_symb_ram: u32,
18852 }
18853 let proxy = Huffsymb31 {
18854 huff_symb_ram: self.huff_symb_ram(),
18855 };
18856 defmt::write!(f, "{}", proxy)
18857 }
18858 }
18859 #[doc = "JPEG HUFFSYMB tables"]
18860 #[repr(transparent)]
18861 #[derive(Copy, Clone, Eq, PartialEq)]
18862 pub struct Huffsymb32(pub u32);
18863 impl Huffsymb32 {
18864 #[doc = "DHTSymb RAM"]
18865 #[inline(always)]
18866 pub const fn huff_symb_ram(&self) -> u32 {
18867 let val = (self.0 >> 0usize) & 0xffff_ffff;
18868 val as u32
18869 }
18870 #[doc = "DHTSymb RAM"]
18871 #[inline(always)]
18872 pub fn set_huff_symb_ram(&mut self, val: u32) {
18873 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18874 }
18875 }
18876 impl Default for Huffsymb32 {
18877 #[inline(always)]
18878 fn default() -> Huffsymb32 {
18879 Huffsymb32(0)
18880 }
18881 }
18882 impl core::fmt::Debug for Huffsymb32 {
18883 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18884 f.debug_struct("Huffsymb32")
18885 .field("huff_symb_ram", &self.huff_symb_ram())
18886 .finish()
18887 }
18888 }
18889 #[cfg(feature = "defmt")]
18890 impl defmt::Format for Huffsymb32 {
18891 fn format(&self, f: defmt::Formatter) {
18892 #[derive(defmt :: Format)]
18893 struct Huffsymb32 {
18894 huff_symb_ram: u32,
18895 }
18896 let proxy = Huffsymb32 {
18897 huff_symb_ram: self.huff_symb_ram(),
18898 };
18899 defmt::write!(f, "{}", proxy)
18900 }
18901 }
18902 #[doc = "JPEG HUFFSYMB tables"]
18903 #[repr(transparent)]
18904 #[derive(Copy, Clone, Eq, PartialEq)]
18905 pub struct Huffsymb33(pub u32);
18906 impl Huffsymb33 {
18907 #[doc = "DHTSymb RAM"]
18908 #[inline(always)]
18909 pub const fn huff_symb_ram(&self) -> u32 {
18910 let val = (self.0 >> 0usize) & 0xffff_ffff;
18911 val as u32
18912 }
18913 #[doc = "DHTSymb RAM"]
18914 #[inline(always)]
18915 pub fn set_huff_symb_ram(&mut self, val: u32) {
18916 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18917 }
18918 }
18919 impl Default for Huffsymb33 {
18920 #[inline(always)]
18921 fn default() -> Huffsymb33 {
18922 Huffsymb33(0)
18923 }
18924 }
18925 impl core::fmt::Debug for Huffsymb33 {
18926 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18927 f.debug_struct("Huffsymb33")
18928 .field("huff_symb_ram", &self.huff_symb_ram())
18929 .finish()
18930 }
18931 }
18932 #[cfg(feature = "defmt")]
18933 impl defmt::Format for Huffsymb33 {
18934 fn format(&self, f: defmt::Formatter) {
18935 #[derive(defmt :: Format)]
18936 struct Huffsymb33 {
18937 huff_symb_ram: u32,
18938 }
18939 let proxy = Huffsymb33 {
18940 huff_symb_ram: self.huff_symb_ram(),
18941 };
18942 defmt::write!(f, "{}", proxy)
18943 }
18944 }
18945 #[doc = "JPEG HUFFSYMB tables"]
18946 #[repr(transparent)]
18947 #[derive(Copy, Clone, Eq, PartialEq)]
18948 pub struct Huffsymb34(pub u32);
18949 impl Huffsymb34 {
18950 #[doc = "DHTSymb RAM"]
18951 #[inline(always)]
18952 pub const fn huff_symb_ram(&self) -> u32 {
18953 let val = (self.0 >> 0usize) & 0xffff_ffff;
18954 val as u32
18955 }
18956 #[doc = "DHTSymb RAM"]
18957 #[inline(always)]
18958 pub fn set_huff_symb_ram(&mut self, val: u32) {
18959 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
18960 }
18961 }
18962 impl Default for Huffsymb34 {
18963 #[inline(always)]
18964 fn default() -> Huffsymb34 {
18965 Huffsymb34(0)
18966 }
18967 }
18968 impl core::fmt::Debug for Huffsymb34 {
18969 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
18970 f.debug_struct("Huffsymb34")
18971 .field("huff_symb_ram", &self.huff_symb_ram())
18972 .finish()
18973 }
18974 }
18975 #[cfg(feature = "defmt")]
18976 impl defmt::Format for Huffsymb34 {
18977 fn format(&self, f: defmt::Formatter) {
18978 #[derive(defmt :: Format)]
18979 struct Huffsymb34 {
18980 huff_symb_ram: u32,
18981 }
18982 let proxy = Huffsymb34 {
18983 huff_symb_ram: self.huff_symb_ram(),
18984 };
18985 defmt::write!(f, "{}", proxy)
18986 }
18987 }
18988 #[doc = "JPEG HUFFSYMB tables"]
18989 #[repr(transparent)]
18990 #[derive(Copy, Clone, Eq, PartialEq)]
18991 pub struct Huffsymb35(pub u32);
18992 impl Huffsymb35 {
18993 #[doc = "DHTSymb RAM"]
18994 #[inline(always)]
18995 pub const fn huff_symb_ram(&self) -> u32 {
18996 let val = (self.0 >> 0usize) & 0xffff_ffff;
18997 val as u32
18998 }
18999 #[doc = "DHTSymb RAM"]
19000 #[inline(always)]
19001 pub fn set_huff_symb_ram(&mut self, val: u32) {
19002 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19003 }
19004 }
19005 impl Default for Huffsymb35 {
19006 #[inline(always)]
19007 fn default() -> Huffsymb35 {
19008 Huffsymb35(0)
19009 }
19010 }
19011 impl core::fmt::Debug for Huffsymb35 {
19012 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19013 f.debug_struct("Huffsymb35")
19014 .field("huff_symb_ram", &self.huff_symb_ram())
19015 .finish()
19016 }
19017 }
19018 #[cfg(feature = "defmt")]
19019 impl defmt::Format for Huffsymb35 {
19020 fn format(&self, f: defmt::Formatter) {
19021 #[derive(defmt :: Format)]
19022 struct Huffsymb35 {
19023 huff_symb_ram: u32,
19024 }
19025 let proxy = Huffsymb35 {
19026 huff_symb_ram: self.huff_symb_ram(),
19027 };
19028 defmt::write!(f, "{}", proxy)
19029 }
19030 }
19031 #[doc = "JPEG HUFFSYMB tables"]
19032 #[repr(transparent)]
19033 #[derive(Copy, Clone, Eq, PartialEq)]
19034 pub struct Huffsymb36(pub u32);
19035 impl Huffsymb36 {
19036 #[doc = "DHTSymb RAM"]
19037 #[inline(always)]
19038 pub const fn huff_symb_ram(&self) -> u32 {
19039 let val = (self.0 >> 0usize) & 0xffff_ffff;
19040 val as u32
19041 }
19042 #[doc = "DHTSymb RAM"]
19043 #[inline(always)]
19044 pub fn set_huff_symb_ram(&mut self, val: u32) {
19045 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19046 }
19047 }
19048 impl Default for Huffsymb36 {
19049 #[inline(always)]
19050 fn default() -> Huffsymb36 {
19051 Huffsymb36(0)
19052 }
19053 }
19054 impl core::fmt::Debug for Huffsymb36 {
19055 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19056 f.debug_struct("Huffsymb36")
19057 .field("huff_symb_ram", &self.huff_symb_ram())
19058 .finish()
19059 }
19060 }
19061 #[cfg(feature = "defmt")]
19062 impl defmt::Format for Huffsymb36 {
19063 fn format(&self, f: defmt::Formatter) {
19064 #[derive(defmt :: Format)]
19065 struct Huffsymb36 {
19066 huff_symb_ram: u32,
19067 }
19068 let proxy = Huffsymb36 {
19069 huff_symb_ram: self.huff_symb_ram(),
19070 };
19071 defmt::write!(f, "{}", proxy)
19072 }
19073 }
19074 #[doc = "JPEG HUFFSYMB tables"]
19075 #[repr(transparent)]
19076 #[derive(Copy, Clone, Eq, PartialEq)]
19077 pub struct Huffsymb37(pub u32);
19078 impl Huffsymb37 {
19079 #[doc = "DHTSymb RAM"]
19080 #[inline(always)]
19081 pub const fn huff_symb_ram(&self) -> u32 {
19082 let val = (self.0 >> 0usize) & 0xffff_ffff;
19083 val as u32
19084 }
19085 #[doc = "DHTSymb RAM"]
19086 #[inline(always)]
19087 pub fn set_huff_symb_ram(&mut self, val: u32) {
19088 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19089 }
19090 }
19091 impl Default for Huffsymb37 {
19092 #[inline(always)]
19093 fn default() -> Huffsymb37 {
19094 Huffsymb37(0)
19095 }
19096 }
19097 impl core::fmt::Debug for Huffsymb37 {
19098 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19099 f.debug_struct("Huffsymb37")
19100 .field("huff_symb_ram", &self.huff_symb_ram())
19101 .finish()
19102 }
19103 }
19104 #[cfg(feature = "defmt")]
19105 impl defmt::Format for Huffsymb37 {
19106 fn format(&self, f: defmt::Formatter) {
19107 #[derive(defmt :: Format)]
19108 struct Huffsymb37 {
19109 huff_symb_ram: u32,
19110 }
19111 let proxy = Huffsymb37 {
19112 huff_symb_ram: self.huff_symb_ram(),
19113 };
19114 defmt::write!(f, "{}", proxy)
19115 }
19116 }
19117 #[doc = "JPEG HUFFSYMB tables"]
19118 #[repr(transparent)]
19119 #[derive(Copy, Clone, Eq, PartialEq)]
19120 pub struct Huffsymb38(pub u32);
19121 impl Huffsymb38 {
19122 #[doc = "DHTSymb RAM"]
19123 #[inline(always)]
19124 pub const fn huff_symb_ram(&self) -> u32 {
19125 let val = (self.0 >> 0usize) & 0xffff_ffff;
19126 val as u32
19127 }
19128 #[doc = "DHTSymb RAM"]
19129 #[inline(always)]
19130 pub fn set_huff_symb_ram(&mut self, val: u32) {
19131 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19132 }
19133 }
19134 impl Default for Huffsymb38 {
19135 #[inline(always)]
19136 fn default() -> Huffsymb38 {
19137 Huffsymb38(0)
19138 }
19139 }
19140 impl core::fmt::Debug for Huffsymb38 {
19141 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19142 f.debug_struct("Huffsymb38")
19143 .field("huff_symb_ram", &self.huff_symb_ram())
19144 .finish()
19145 }
19146 }
19147 #[cfg(feature = "defmt")]
19148 impl defmt::Format for Huffsymb38 {
19149 fn format(&self, f: defmt::Formatter) {
19150 #[derive(defmt :: Format)]
19151 struct Huffsymb38 {
19152 huff_symb_ram: u32,
19153 }
19154 let proxy = Huffsymb38 {
19155 huff_symb_ram: self.huff_symb_ram(),
19156 };
19157 defmt::write!(f, "{}", proxy)
19158 }
19159 }
19160 #[doc = "JPEG HUFFSYMB tables"]
19161 #[repr(transparent)]
19162 #[derive(Copy, Clone, Eq, PartialEq)]
19163 pub struct Huffsymb39(pub u32);
19164 impl Huffsymb39 {
19165 #[doc = "DHTSymb RAM"]
19166 #[inline(always)]
19167 pub const fn huff_symb_ram(&self) -> u32 {
19168 let val = (self.0 >> 0usize) & 0xffff_ffff;
19169 val as u32
19170 }
19171 #[doc = "DHTSymb RAM"]
19172 #[inline(always)]
19173 pub fn set_huff_symb_ram(&mut self, val: u32) {
19174 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19175 }
19176 }
19177 impl Default for Huffsymb39 {
19178 #[inline(always)]
19179 fn default() -> Huffsymb39 {
19180 Huffsymb39(0)
19181 }
19182 }
19183 impl core::fmt::Debug for Huffsymb39 {
19184 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19185 f.debug_struct("Huffsymb39")
19186 .field("huff_symb_ram", &self.huff_symb_ram())
19187 .finish()
19188 }
19189 }
19190 #[cfg(feature = "defmt")]
19191 impl defmt::Format for Huffsymb39 {
19192 fn format(&self, f: defmt::Formatter) {
19193 #[derive(defmt :: Format)]
19194 struct Huffsymb39 {
19195 huff_symb_ram: u32,
19196 }
19197 let proxy = Huffsymb39 {
19198 huff_symb_ram: self.huff_symb_ram(),
19199 };
19200 defmt::write!(f, "{}", proxy)
19201 }
19202 }
19203 #[doc = "JPEG HUFFSYMB tables"]
19204 #[repr(transparent)]
19205 #[derive(Copy, Clone, Eq, PartialEq)]
19206 pub struct Huffsymb4(pub u32);
19207 impl Huffsymb4 {
19208 #[doc = "DHTSymb RAM"]
19209 #[inline(always)]
19210 pub const fn huff_symb_ram(&self) -> u32 {
19211 let val = (self.0 >> 0usize) & 0xffff_ffff;
19212 val as u32
19213 }
19214 #[doc = "DHTSymb RAM"]
19215 #[inline(always)]
19216 pub fn set_huff_symb_ram(&mut self, val: u32) {
19217 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19218 }
19219 }
19220 impl Default for Huffsymb4 {
19221 #[inline(always)]
19222 fn default() -> Huffsymb4 {
19223 Huffsymb4(0)
19224 }
19225 }
19226 impl core::fmt::Debug for Huffsymb4 {
19227 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19228 f.debug_struct("Huffsymb4")
19229 .field("huff_symb_ram", &self.huff_symb_ram())
19230 .finish()
19231 }
19232 }
19233 #[cfg(feature = "defmt")]
19234 impl defmt::Format for Huffsymb4 {
19235 fn format(&self, f: defmt::Formatter) {
19236 #[derive(defmt :: Format)]
19237 struct Huffsymb4 {
19238 huff_symb_ram: u32,
19239 }
19240 let proxy = Huffsymb4 {
19241 huff_symb_ram: self.huff_symb_ram(),
19242 };
19243 defmt::write!(f, "{}", proxy)
19244 }
19245 }
19246 #[doc = "JPEG HUFFSYMB tables"]
19247 #[repr(transparent)]
19248 #[derive(Copy, Clone, Eq, PartialEq)]
19249 pub struct Huffsymb40(pub u32);
19250 impl Huffsymb40 {
19251 #[doc = "DHTSymb RAM"]
19252 #[inline(always)]
19253 pub const fn huff_symb_ram(&self) -> u32 {
19254 let val = (self.0 >> 0usize) & 0xffff_ffff;
19255 val as u32
19256 }
19257 #[doc = "DHTSymb RAM"]
19258 #[inline(always)]
19259 pub fn set_huff_symb_ram(&mut self, val: u32) {
19260 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19261 }
19262 }
19263 impl Default for Huffsymb40 {
19264 #[inline(always)]
19265 fn default() -> Huffsymb40 {
19266 Huffsymb40(0)
19267 }
19268 }
19269 impl core::fmt::Debug for Huffsymb40 {
19270 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19271 f.debug_struct("Huffsymb40")
19272 .field("huff_symb_ram", &self.huff_symb_ram())
19273 .finish()
19274 }
19275 }
19276 #[cfg(feature = "defmt")]
19277 impl defmt::Format for Huffsymb40 {
19278 fn format(&self, f: defmt::Formatter) {
19279 #[derive(defmt :: Format)]
19280 struct Huffsymb40 {
19281 huff_symb_ram: u32,
19282 }
19283 let proxy = Huffsymb40 {
19284 huff_symb_ram: self.huff_symb_ram(),
19285 };
19286 defmt::write!(f, "{}", proxy)
19287 }
19288 }
19289 #[doc = "JPEG HUFFSYMB tables"]
19290 #[repr(transparent)]
19291 #[derive(Copy, Clone, Eq, PartialEq)]
19292 pub struct Huffsymb41(pub u32);
19293 impl Huffsymb41 {
19294 #[doc = "DHTSymb RAM"]
19295 #[inline(always)]
19296 pub const fn huff_symb_ram(&self) -> u32 {
19297 let val = (self.0 >> 0usize) & 0xffff_ffff;
19298 val as u32
19299 }
19300 #[doc = "DHTSymb RAM"]
19301 #[inline(always)]
19302 pub fn set_huff_symb_ram(&mut self, val: u32) {
19303 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19304 }
19305 }
19306 impl Default for Huffsymb41 {
19307 #[inline(always)]
19308 fn default() -> Huffsymb41 {
19309 Huffsymb41(0)
19310 }
19311 }
19312 impl core::fmt::Debug for Huffsymb41 {
19313 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19314 f.debug_struct("Huffsymb41")
19315 .field("huff_symb_ram", &self.huff_symb_ram())
19316 .finish()
19317 }
19318 }
19319 #[cfg(feature = "defmt")]
19320 impl defmt::Format for Huffsymb41 {
19321 fn format(&self, f: defmt::Formatter) {
19322 #[derive(defmt :: Format)]
19323 struct Huffsymb41 {
19324 huff_symb_ram: u32,
19325 }
19326 let proxy = Huffsymb41 {
19327 huff_symb_ram: self.huff_symb_ram(),
19328 };
19329 defmt::write!(f, "{}", proxy)
19330 }
19331 }
19332 #[doc = "JPEG HUFFSYMB tables"]
19333 #[repr(transparent)]
19334 #[derive(Copy, Clone, Eq, PartialEq)]
19335 pub struct Huffsymb42(pub u32);
19336 impl Huffsymb42 {
19337 #[doc = "DHTSymb RAM"]
19338 #[inline(always)]
19339 pub const fn huff_symb_ram(&self) -> u32 {
19340 let val = (self.0 >> 0usize) & 0xffff_ffff;
19341 val as u32
19342 }
19343 #[doc = "DHTSymb RAM"]
19344 #[inline(always)]
19345 pub fn set_huff_symb_ram(&mut self, val: u32) {
19346 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19347 }
19348 }
19349 impl Default for Huffsymb42 {
19350 #[inline(always)]
19351 fn default() -> Huffsymb42 {
19352 Huffsymb42(0)
19353 }
19354 }
19355 impl core::fmt::Debug for Huffsymb42 {
19356 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19357 f.debug_struct("Huffsymb42")
19358 .field("huff_symb_ram", &self.huff_symb_ram())
19359 .finish()
19360 }
19361 }
19362 #[cfg(feature = "defmt")]
19363 impl defmt::Format for Huffsymb42 {
19364 fn format(&self, f: defmt::Formatter) {
19365 #[derive(defmt :: Format)]
19366 struct Huffsymb42 {
19367 huff_symb_ram: u32,
19368 }
19369 let proxy = Huffsymb42 {
19370 huff_symb_ram: self.huff_symb_ram(),
19371 };
19372 defmt::write!(f, "{}", proxy)
19373 }
19374 }
19375 #[doc = "JPEG HUFFSYMB tables"]
19376 #[repr(transparent)]
19377 #[derive(Copy, Clone, Eq, PartialEq)]
19378 pub struct Huffsymb43(pub u32);
19379 impl Huffsymb43 {
19380 #[doc = "DHTSymb RAM"]
19381 #[inline(always)]
19382 pub const fn huff_symb_ram(&self) -> u32 {
19383 let val = (self.0 >> 0usize) & 0xffff_ffff;
19384 val as u32
19385 }
19386 #[doc = "DHTSymb RAM"]
19387 #[inline(always)]
19388 pub fn set_huff_symb_ram(&mut self, val: u32) {
19389 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19390 }
19391 }
19392 impl Default for Huffsymb43 {
19393 #[inline(always)]
19394 fn default() -> Huffsymb43 {
19395 Huffsymb43(0)
19396 }
19397 }
19398 impl core::fmt::Debug for Huffsymb43 {
19399 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19400 f.debug_struct("Huffsymb43")
19401 .field("huff_symb_ram", &self.huff_symb_ram())
19402 .finish()
19403 }
19404 }
19405 #[cfg(feature = "defmt")]
19406 impl defmt::Format for Huffsymb43 {
19407 fn format(&self, f: defmt::Formatter) {
19408 #[derive(defmt :: Format)]
19409 struct Huffsymb43 {
19410 huff_symb_ram: u32,
19411 }
19412 let proxy = Huffsymb43 {
19413 huff_symb_ram: self.huff_symb_ram(),
19414 };
19415 defmt::write!(f, "{}", proxy)
19416 }
19417 }
19418 #[doc = "JPEG HUFFSYMB tables"]
19419 #[repr(transparent)]
19420 #[derive(Copy, Clone, Eq, PartialEq)]
19421 pub struct Huffsymb44(pub u32);
19422 impl Huffsymb44 {
19423 #[doc = "DHTSymb RAM"]
19424 #[inline(always)]
19425 pub const fn huff_symb_ram(&self) -> u32 {
19426 let val = (self.0 >> 0usize) & 0xffff_ffff;
19427 val as u32
19428 }
19429 #[doc = "DHTSymb RAM"]
19430 #[inline(always)]
19431 pub fn set_huff_symb_ram(&mut self, val: u32) {
19432 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19433 }
19434 }
19435 impl Default for Huffsymb44 {
19436 #[inline(always)]
19437 fn default() -> Huffsymb44 {
19438 Huffsymb44(0)
19439 }
19440 }
19441 impl core::fmt::Debug for Huffsymb44 {
19442 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19443 f.debug_struct("Huffsymb44")
19444 .field("huff_symb_ram", &self.huff_symb_ram())
19445 .finish()
19446 }
19447 }
19448 #[cfg(feature = "defmt")]
19449 impl defmt::Format for Huffsymb44 {
19450 fn format(&self, f: defmt::Formatter) {
19451 #[derive(defmt :: Format)]
19452 struct Huffsymb44 {
19453 huff_symb_ram: u32,
19454 }
19455 let proxy = Huffsymb44 {
19456 huff_symb_ram: self.huff_symb_ram(),
19457 };
19458 defmt::write!(f, "{}", proxy)
19459 }
19460 }
19461 #[doc = "JPEG HUFFSYMB tables"]
19462 #[repr(transparent)]
19463 #[derive(Copy, Clone, Eq, PartialEq)]
19464 pub struct Huffsymb45(pub u32);
19465 impl Huffsymb45 {
19466 #[doc = "DHTSymb RAM"]
19467 #[inline(always)]
19468 pub const fn huff_symb_ram(&self) -> u32 {
19469 let val = (self.0 >> 0usize) & 0xffff_ffff;
19470 val as u32
19471 }
19472 #[doc = "DHTSymb RAM"]
19473 #[inline(always)]
19474 pub fn set_huff_symb_ram(&mut self, val: u32) {
19475 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19476 }
19477 }
19478 impl Default for Huffsymb45 {
19479 #[inline(always)]
19480 fn default() -> Huffsymb45 {
19481 Huffsymb45(0)
19482 }
19483 }
19484 impl core::fmt::Debug for Huffsymb45 {
19485 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19486 f.debug_struct("Huffsymb45")
19487 .field("huff_symb_ram", &self.huff_symb_ram())
19488 .finish()
19489 }
19490 }
19491 #[cfg(feature = "defmt")]
19492 impl defmt::Format for Huffsymb45 {
19493 fn format(&self, f: defmt::Formatter) {
19494 #[derive(defmt :: Format)]
19495 struct Huffsymb45 {
19496 huff_symb_ram: u32,
19497 }
19498 let proxy = Huffsymb45 {
19499 huff_symb_ram: self.huff_symb_ram(),
19500 };
19501 defmt::write!(f, "{}", proxy)
19502 }
19503 }
19504 #[doc = "JPEG HUFFSYMB tables"]
19505 #[repr(transparent)]
19506 #[derive(Copy, Clone, Eq, PartialEq)]
19507 pub struct Huffsymb46(pub u32);
19508 impl Huffsymb46 {
19509 #[doc = "DHTSymb RAM"]
19510 #[inline(always)]
19511 pub const fn huff_symb_ram(&self) -> u32 {
19512 let val = (self.0 >> 0usize) & 0xffff_ffff;
19513 val as u32
19514 }
19515 #[doc = "DHTSymb RAM"]
19516 #[inline(always)]
19517 pub fn set_huff_symb_ram(&mut self, val: u32) {
19518 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19519 }
19520 }
19521 impl Default for Huffsymb46 {
19522 #[inline(always)]
19523 fn default() -> Huffsymb46 {
19524 Huffsymb46(0)
19525 }
19526 }
19527 impl core::fmt::Debug for Huffsymb46 {
19528 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19529 f.debug_struct("Huffsymb46")
19530 .field("huff_symb_ram", &self.huff_symb_ram())
19531 .finish()
19532 }
19533 }
19534 #[cfg(feature = "defmt")]
19535 impl defmt::Format for Huffsymb46 {
19536 fn format(&self, f: defmt::Formatter) {
19537 #[derive(defmt :: Format)]
19538 struct Huffsymb46 {
19539 huff_symb_ram: u32,
19540 }
19541 let proxy = Huffsymb46 {
19542 huff_symb_ram: self.huff_symb_ram(),
19543 };
19544 defmt::write!(f, "{}", proxy)
19545 }
19546 }
19547 #[doc = "JPEG HUFFSYMB tables"]
19548 #[repr(transparent)]
19549 #[derive(Copy, Clone, Eq, PartialEq)]
19550 pub struct Huffsymb47(pub u32);
19551 impl Huffsymb47 {
19552 #[doc = "DHTSymb RAM"]
19553 #[inline(always)]
19554 pub const fn huff_symb_ram(&self) -> u32 {
19555 let val = (self.0 >> 0usize) & 0xffff_ffff;
19556 val as u32
19557 }
19558 #[doc = "DHTSymb RAM"]
19559 #[inline(always)]
19560 pub fn set_huff_symb_ram(&mut self, val: u32) {
19561 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19562 }
19563 }
19564 impl Default for Huffsymb47 {
19565 #[inline(always)]
19566 fn default() -> Huffsymb47 {
19567 Huffsymb47(0)
19568 }
19569 }
19570 impl core::fmt::Debug for Huffsymb47 {
19571 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19572 f.debug_struct("Huffsymb47")
19573 .field("huff_symb_ram", &self.huff_symb_ram())
19574 .finish()
19575 }
19576 }
19577 #[cfg(feature = "defmt")]
19578 impl defmt::Format for Huffsymb47 {
19579 fn format(&self, f: defmt::Formatter) {
19580 #[derive(defmt :: Format)]
19581 struct Huffsymb47 {
19582 huff_symb_ram: u32,
19583 }
19584 let proxy = Huffsymb47 {
19585 huff_symb_ram: self.huff_symb_ram(),
19586 };
19587 defmt::write!(f, "{}", proxy)
19588 }
19589 }
19590 #[doc = "JPEG HUFFSYMB tables"]
19591 #[repr(transparent)]
19592 #[derive(Copy, Clone, Eq, PartialEq)]
19593 pub struct Huffsymb48(pub u32);
19594 impl Huffsymb48 {
19595 #[doc = "DHTSymb RAM"]
19596 #[inline(always)]
19597 pub const fn huff_symb_ram(&self) -> u32 {
19598 let val = (self.0 >> 0usize) & 0xffff_ffff;
19599 val as u32
19600 }
19601 #[doc = "DHTSymb RAM"]
19602 #[inline(always)]
19603 pub fn set_huff_symb_ram(&mut self, val: u32) {
19604 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19605 }
19606 }
19607 impl Default for Huffsymb48 {
19608 #[inline(always)]
19609 fn default() -> Huffsymb48 {
19610 Huffsymb48(0)
19611 }
19612 }
19613 impl core::fmt::Debug for Huffsymb48 {
19614 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19615 f.debug_struct("Huffsymb48")
19616 .field("huff_symb_ram", &self.huff_symb_ram())
19617 .finish()
19618 }
19619 }
19620 #[cfg(feature = "defmt")]
19621 impl defmt::Format for Huffsymb48 {
19622 fn format(&self, f: defmt::Formatter) {
19623 #[derive(defmt :: Format)]
19624 struct Huffsymb48 {
19625 huff_symb_ram: u32,
19626 }
19627 let proxy = Huffsymb48 {
19628 huff_symb_ram: self.huff_symb_ram(),
19629 };
19630 defmt::write!(f, "{}", proxy)
19631 }
19632 }
19633 #[doc = "JPEG HUFFSYMB tables"]
19634 #[repr(transparent)]
19635 #[derive(Copy, Clone, Eq, PartialEq)]
19636 pub struct Huffsymb49(pub u32);
19637 impl Huffsymb49 {
19638 #[doc = "DHTSymb RAM"]
19639 #[inline(always)]
19640 pub const fn huff_symb_ram(&self) -> u32 {
19641 let val = (self.0 >> 0usize) & 0xffff_ffff;
19642 val as u32
19643 }
19644 #[doc = "DHTSymb RAM"]
19645 #[inline(always)]
19646 pub fn set_huff_symb_ram(&mut self, val: u32) {
19647 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19648 }
19649 }
19650 impl Default for Huffsymb49 {
19651 #[inline(always)]
19652 fn default() -> Huffsymb49 {
19653 Huffsymb49(0)
19654 }
19655 }
19656 impl core::fmt::Debug for Huffsymb49 {
19657 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19658 f.debug_struct("Huffsymb49")
19659 .field("huff_symb_ram", &self.huff_symb_ram())
19660 .finish()
19661 }
19662 }
19663 #[cfg(feature = "defmt")]
19664 impl defmt::Format for Huffsymb49 {
19665 fn format(&self, f: defmt::Formatter) {
19666 #[derive(defmt :: Format)]
19667 struct Huffsymb49 {
19668 huff_symb_ram: u32,
19669 }
19670 let proxy = Huffsymb49 {
19671 huff_symb_ram: self.huff_symb_ram(),
19672 };
19673 defmt::write!(f, "{}", proxy)
19674 }
19675 }
19676 #[doc = "JPEG HUFFSYMB tables"]
19677 #[repr(transparent)]
19678 #[derive(Copy, Clone, Eq, PartialEq)]
19679 pub struct Huffsymb5(pub u32);
19680 impl Huffsymb5 {
19681 #[doc = "DHTSymb RAM"]
19682 #[inline(always)]
19683 pub const fn huff_symb_ram(&self) -> u32 {
19684 let val = (self.0 >> 0usize) & 0xffff_ffff;
19685 val as u32
19686 }
19687 #[doc = "DHTSymb RAM"]
19688 #[inline(always)]
19689 pub fn set_huff_symb_ram(&mut self, val: u32) {
19690 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19691 }
19692 }
19693 impl Default for Huffsymb5 {
19694 #[inline(always)]
19695 fn default() -> Huffsymb5 {
19696 Huffsymb5(0)
19697 }
19698 }
19699 impl core::fmt::Debug for Huffsymb5 {
19700 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19701 f.debug_struct("Huffsymb5")
19702 .field("huff_symb_ram", &self.huff_symb_ram())
19703 .finish()
19704 }
19705 }
19706 #[cfg(feature = "defmt")]
19707 impl defmt::Format for Huffsymb5 {
19708 fn format(&self, f: defmt::Formatter) {
19709 #[derive(defmt :: Format)]
19710 struct Huffsymb5 {
19711 huff_symb_ram: u32,
19712 }
19713 let proxy = Huffsymb5 {
19714 huff_symb_ram: self.huff_symb_ram(),
19715 };
19716 defmt::write!(f, "{}", proxy)
19717 }
19718 }
19719 #[doc = "JPEG HUFFSYMB tables"]
19720 #[repr(transparent)]
19721 #[derive(Copy, Clone, Eq, PartialEq)]
19722 pub struct Huffsymb50(pub u32);
19723 impl Huffsymb50 {
19724 #[doc = "DHTSymb RAM"]
19725 #[inline(always)]
19726 pub const fn huff_symb_ram(&self) -> u32 {
19727 let val = (self.0 >> 0usize) & 0xffff_ffff;
19728 val as u32
19729 }
19730 #[doc = "DHTSymb RAM"]
19731 #[inline(always)]
19732 pub fn set_huff_symb_ram(&mut self, val: u32) {
19733 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19734 }
19735 }
19736 impl Default for Huffsymb50 {
19737 #[inline(always)]
19738 fn default() -> Huffsymb50 {
19739 Huffsymb50(0)
19740 }
19741 }
19742 impl core::fmt::Debug for Huffsymb50 {
19743 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19744 f.debug_struct("Huffsymb50")
19745 .field("huff_symb_ram", &self.huff_symb_ram())
19746 .finish()
19747 }
19748 }
19749 #[cfg(feature = "defmt")]
19750 impl defmt::Format for Huffsymb50 {
19751 fn format(&self, f: defmt::Formatter) {
19752 #[derive(defmt :: Format)]
19753 struct Huffsymb50 {
19754 huff_symb_ram: u32,
19755 }
19756 let proxy = Huffsymb50 {
19757 huff_symb_ram: self.huff_symb_ram(),
19758 };
19759 defmt::write!(f, "{}", proxy)
19760 }
19761 }
19762 #[doc = "JPEG HUFFSYMB tables"]
19763 #[repr(transparent)]
19764 #[derive(Copy, Clone, Eq, PartialEq)]
19765 pub struct Huffsymb51(pub u32);
19766 impl Huffsymb51 {
19767 #[doc = "DHTSymb RAM"]
19768 #[inline(always)]
19769 pub const fn huff_symb_ram(&self) -> u32 {
19770 let val = (self.0 >> 0usize) & 0xffff_ffff;
19771 val as u32
19772 }
19773 #[doc = "DHTSymb RAM"]
19774 #[inline(always)]
19775 pub fn set_huff_symb_ram(&mut self, val: u32) {
19776 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19777 }
19778 }
19779 impl Default for Huffsymb51 {
19780 #[inline(always)]
19781 fn default() -> Huffsymb51 {
19782 Huffsymb51(0)
19783 }
19784 }
19785 impl core::fmt::Debug for Huffsymb51 {
19786 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19787 f.debug_struct("Huffsymb51")
19788 .field("huff_symb_ram", &self.huff_symb_ram())
19789 .finish()
19790 }
19791 }
19792 #[cfg(feature = "defmt")]
19793 impl defmt::Format for Huffsymb51 {
19794 fn format(&self, f: defmt::Formatter) {
19795 #[derive(defmt :: Format)]
19796 struct Huffsymb51 {
19797 huff_symb_ram: u32,
19798 }
19799 let proxy = Huffsymb51 {
19800 huff_symb_ram: self.huff_symb_ram(),
19801 };
19802 defmt::write!(f, "{}", proxy)
19803 }
19804 }
19805 #[doc = "JPEG HUFFSYMB tables"]
19806 #[repr(transparent)]
19807 #[derive(Copy, Clone, Eq, PartialEq)]
19808 pub struct Huffsymb52(pub u32);
19809 impl Huffsymb52 {
19810 #[doc = "DHTSymb RAM"]
19811 #[inline(always)]
19812 pub const fn huff_symb_ram(&self) -> u32 {
19813 let val = (self.0 >> 0usize) & 0xffff_ffff;
19814 val as u32
19815 }
19816 #[doc = "DHTSymb RAM"]
19817 #[inline(always)]
19818 pub fn set_huff_symb_ram(&mut self, val: u32) {
19819 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19820 }
19821 }
19822 impl Default for Huffsymb52 {
19823 #[inline(always)]
19824 fn default() -> Huffsymb52 {
19825 Huffsymb52(0)
19826 }
19827 }
19828 impl core::fmt::Debug for Huffsymb52 {
19829 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19830 f.debug_struct("Huffsymb52")
19831 .field("huff_symb_ram", &self.huff_symb_ram())
19832 .finish()
19833 }
19834 }
19835 #[cfg(feature = "defmt")]
19836 impl defmt::Format for Huffsymb52 {
19837 fn format(&self, f: defmt::Formatter) {
19838 #[derive(defmt :: Format)]
19839 struct Huffsymb52 {
19840 huff_symb_ram: u32,
19841 }
19842 let proxy = Huffsymb52 {
19843 huff_symb_ram: self.huff_symb_ram(),
19844 };
19845 defmt::write!(f, "{}", proxy)
19846 }
19847 }
19848 #[doc = "JPEG HUFFSYMB tables"]
19849 #[repr(transparent)]
19850 #[derive(Copy, Clone, Eq, PartialEq)]
19851 pub struct Huffsymb53(pub u32);
19852 impl Huffsymb53 {
19853 #[doc = "DHTSymb RAM"]
19854 #[inline(always)]
19855 pub const fn huff_symb_ram(&self) -> u32 {
19856 let val = (self.0 >> 0usize) & 0xffff_ffff;
19857 val as u32
19858 }
19859 #[doc = "DHTSymb RAM"]
19860 #[inline(always)]
19861 pub fn set_huff_symb_ram(&mut self, val: u32) {
19862 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19863 }
19864 }
19865 impl Default for Huffsymb53 {
19866 #[inline(always)]
19867 fn default() -> Huffsymb53 {
19868 Huffsymb53(0)
19869 }
19870 }
19871 impl core::fmt::Debug for Huffsymb53 {
19872 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19873 f.debug_struct("Huffsymb53")
19874 .field("huff_symb_ram", &self.huff_symb_ram())
19875 .finish()
19876 }
19877 }
19878 #[cfg(feature = "defmt")]
19879 impl defmt::Format for Huffsymb53 {
19880 fn format(&self, f: defmt::Formatter) {
19881 #[derive(defmt :: Format)]
19882 struct Huffsymb53 {
19883 huff_symb_ram: u32,
19884 }
19885 let proxy = Huffsymb53 {
19886 huff_symb_ram: self.huff_symb_ram(),
19887 };
19888 defmt::write!(f, "{}", proxy)
19889 }
19890 }
19891 #[doc = "JPEG HUFFSYMB tables"]
19892 #[repr(transparent)]
19893 #[derive(Copy, Clone, Eq, PartialEq)]
19894 pub struct Huffsymb54(pub u32);
19895 impl Huffsymb54 {
19896 #[doc = "DHTSymb RAM"]
19897 #[inline(always)]
19898 pub const fn huff_symb_ram(&self) -> u32 {
19899 let val = (self.0 >> 0usize) & 0xffff_ffff;
19900 val as u32
19901 }
19902 #[doc = "DHTSymb RAM"]
19903 #[inline(always)]
19904 pub fn set_huff_symb_ram(&mut self, val: u32) {
19905 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19906 }
19907 }
19908 impl Default for Huffsymb54 {
19909 #[inline(always)]
19910 fn default() -> Huffsymb54 {
19911 Huffsymb54(0)
19912 }
19913 }
19914 impl core::fmt::Debug for Huffsymb54 {
19915 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19916 f.debug_struct("Huffsymb54")
19917 .field("huff_symb_ram", &self.huff_symb_ram())
19918 .finish()
19919 }
19920 }
19921 #[cfg(feature = "defmt")]
19922 impl defmt::Format for Huffsymb54 {
19923 fn format(&self, f: defmt::Formatter) {
19924 #[derive(defmt :: Format)]
19925 struct Huffsymb54 {
19926 huff_symb_ram: u32,
19927 }
19928 let proxy = Huffsymb54 {
19929 huff_symb_ram: self.huff_symb_ram(),
19930 };
19931 defmt::write!(f, "{}", proxy)
19932 }
19933 }
19934 #[doc = "JPEG HUFFSYMB tables"]
19935 #[repr(transparent)]
19936 #[derive(Copy, Clone, Eq, PartialEq)]
19937 pub struct Huffsymb55(pub u32);
19938 impl Huffsymb55 {
19939 #[doc = "DHTSymb RAM"]
19940 #[inline(always)]
19941 pub const fn huff_symb_ram(&self) -> u32 {
19942 let val = (self.0 >> 0usize) & 0xffff_ffff;
19943 val as u32
19944 }
19945 #[doc = "DHTSymb RAM"]
19946 #[inline(always)]
19947 pub fn set_huff_symb_ram(&mut self, val: u32) {
19948 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19949 }
19950 }
19951 impl Default for Huffsymb55 {
19952 #[inline(always)]
19953 fn default() -> Huffsymb55 {
19954 Huffsymb55(0)
19955 }
19956 }
19957 impl core::fmt::Debug for Huffsymb55 {
19958 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
19959 f.debug_struct("Huffsymb55")
19960 .field("huff_symb_ram", &self.huff_symb_ram())
19961 .finish()
19962 }
19963 }
19964 #[cfg(feature = "defmt")]
19965 impl defmt::Format for Huffsymb55 {
19966 fn format(&self, f: defmt::Formatter) {
19967 #[derive(defmt :: Format)]
19968 struct Huffsymb55 {
19969 huff_symb_ram: u32,
19970 }
19971 let proxy = Huffsymb55 {
19972 huff_symb_ram: self.huff_symb_ram(),
19973 };
19974 defmt::write!(f, "{}", proxy)
19975 }
19976 }
19977 #[doc = "JPEG HUFFSYMB tables"]
19978 #[repr(transparent)]
19979 #[derive(Copy, Clone, Eq, PartialEq)]
19980 pub struct Huffsymb56(pub u32);
19981 impl Huffsymb56 {
19982 #[doc = "DHTSymb RAM"]
19983 #[inline(always)]
19984 pub const fn huff_symb_ram(&self) -> u32 {
19985 let val = (self.0 >> 0usize) & 0xffff_ffff;
19986 val as u32
19987 }
19988 #[doc = "DHTSymb RAM"]
19989 #[inline(always)]
19990 pub fn set_huff_symb_ram(&mut self, val: u32) {
19991 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
19992 }
19993 }
19994 impl Default for Huffsymb56 {
19995 #[inline(always)]
19996 fn default() -> Huffsymb56 {
19997 Huffsymb56(0)
19998 }
19999 }
20000 impl core::fmt::Debug for Huffsymb56 {
20001 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20002 f.debug_struct("Huffsymb56")
20003 .field("huff_symb_ram", &self.huff_symb_ram())
20004 .finish()
20005 }
20006 }
20007 #[cfg(feature = "defmt")]
20008 impl defmt::Format for Huffsymb56 {
20009 fn format(&self, f: defmt::Formatter) {
20010 #[derive(defmt :: Format)]
20011 struct Huffsymb56 {
20012 huff_symb_ram: u32,
20013 }
20014 let proxy = Huffsymb56 {
20015 huff_symb_ram: self.huff_symb_ram(),
20016 };
20017 defmt::write!(f, "{}", proxy)
20018 }
20019 }
20020 #[doc = "JPEG HUFFSYMB tables"]
20021 #[repr(transparent)]
20022 #[derive(Copy, Clone, Eq, PartialEq)]
20023 pub struct Huffsymb57(pub u32);
20024 impl Huffsymb57 {
20025 #[doc = "DHTSymb RAM"]
20026 #[inline(always)]
20027 pub const fn huff_symb_ram(&self) -> u32 {
20028 let val = (self.0 >> 0usize) & 0xffff_ffff;
20029 val as u32
20030 }
20031 #[doc = "DHTSymb RAM"]
20032 #[inline(always)]
20033 pub fn set_huff_symb_ram(&mut self, val: u32) {
20034 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20035 }
20036 }
20037 impl Default for Huffsymb57 {
20038 #[inline(always)]
20039 fn default() -> Huffsymb57 {
20040 Huffsymb57(0)
20041 }
20042 }
20043 impl core::fmt::Debug for Huffsymb57 {
20044 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20045 f.debug_struct("Huffsymb57")
20046 .field("huff_symb_ram", &self.huff_symb_ram())
20047 .finish()
20048 }
20049 }
20050 #[cfg(feature = "defmt")]
20051 impl defmt::Format for Huffsymb57 {
20052 fn format(&self, f: defmt::Formatter) {
20053 #[derive(defmt :: Format)]
20054 struct Huffsymb57 {
20055 huff_symb_ram: u32,
20056 }
20057 let proxy = Huffsymb57 {
20058 huff_symb_ram: self.huff_symb_ram(),
20059 };
20060 defmt::write!(f, "{}", proxy)
20061 }
20062 }
20063 #[doc = "JPEG HUFFSYMB tables"]
20064 #[repr(transparent)]
20065 #[derive(Copy, Clone, Eq, PartialEq)]
20066 pub struct Huffsymb58(pub u32);
20067 impl Huffsymb58 {
20068 #[doc = "DHTSymb RAM"]
20069 #[inline(always)]
20070 pub const fn huff_symb_ram(&self) -> u32 {
20071 let val = (self.0 >> 0usize) & 0xffff_ffff;
20072 val as u32
20073 }
20074 #[doc = "DHTSymb RAM"]
20075 #[inline(always)]
20076 pub fn set_huff_symb_ram(&mut self, val: u32) {
20077 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20078 }
20079 }
20080 impl Default for Huffsymb58 {
20081 #[inline(always)]
20082 fn default() -> Huffsymb58 {
20083 Huffsymb58(0)
20084 }
20085 }
20086 impl core::fmt::Debug for Huffsymb58 {
20087 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20088 f.debug_struct("Huffsymb58")
20089 .field("huff_symb_ram", &self.huff_symb_ram())
20090 .finish()
20091 }
20092 }
20093 #[cfg(feature = "defmt")]
20094 impl defmt::Format for Huffsymb58 {
20095 fn format(&self, f: defmt::Formatter) {
20096 #[derive(defmt :: Format)]
20097 struct Huffsymb58 {
20098 huff_symb_ram: u32,
20099 }
20100 let proxy = Huffsymb58 {
20101 huff_symb_ram: self.huff_symb_ram(),
20102 };
20103 defmt::write!(f, "{}", proxy)
20104 }
20105 }
20106 #[doc = "JPEG HUFFSYMB tables"]
20107 #[repr(transparent)]
20108 #[derive(Copy, Clone, Eq, PartialEq)]
20109 pub struct Huffsymb59(pub u32);
20110 impl Huffsymb59 {
20111 #[doc = "DHTSymb RAM"]
20112 #[inline(always)]
20113 pub const fn huff_symb_ram(&self) -> u32 {
20114 let val = (self.0 >> 0usize) & 0xffff_ffff;
20115 val as u32
20116 }
20117 #[doc = "DHTSymb RAM"]
20118 #[inline(always)]
20119 pub fn set_huff_symb_ram(&mut self, val: u32) {
20120 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20121 }
20122 }
20123 impl Default for Huffsymb59 {
20124 #[inline(always)]
20125 fn default() -> Huffsymb59 {
20126 Huffsymb59(0)
20127 }
20128 }
20129 impl core::fmt::Debug for Huffsymb59 {
20130 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20131 f.debug_struct("Huffsymb59")
20132 .field("huff_symb_ram", &self.huff_symb_ram())
20133 .finish()
20134 }
20135 }
20136 #[cfg(feature = "defmt")]
20137 impl defmt::Format for Huffsymb59 {
20138 fn format(&self, f: defmt::Formatter) {
20139 #[derive(defmt :: Format)]
20140 struct Huffsymb59 {
20141 huff_symb_ram: u32,
20142 }
20143 let proxy = Huffsymb59 {
20144 huff_symb_ram: self.huff_symb_ram(),
20145 };
20146 defmt::write!(f, "{}", proxy)
20147 }
20148 }
20149 #[doc = "JPEG HUFFSYMB tables"]
20150 #[repr(transparent)]
20151 #[derive(Copy, Clone, Eq, PartialEq)]
20152 pub struct Huffsymb6(pub u32);
20153 impl Huffsymb6 {
20154 #[doc = "DHTSymb RAM"]
20155 #[inline(always)]
20156 pub const fn huff_symb_ram(&self) -> u32 {
20157 let val = (self.0 >> 0usize) & 0xffff_ffff;
20158 val as u32
20159 }
20160 #[doc = "DHTSymb RAM"]
20161 #[inline(always)]
20162 pub fn set_huff_symb_ram(&mut self, val: u32) {
20163 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20164 }
20165 }
20166 impl Default for Huffsymb6 {
20167 #[inline(always)]
20168 fn default() -> Huffsymb6 {
20169 Huffsymb6(0)
20170 }
20171 }
20172 impl core::fmt::Debug for Huffsymb6 {
20173 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20174 f.debug_struct("Huffsymb6")
20175 .field("huff_symb_ram", &self.huff_symb_ram())
20176 .finish()
20177 }
20178 }
20179 #[cfg(feature = "defmt")]
20180 impl defmt::Format for Huffsymb6 {
20181 fn format(&self, f: defmt::Formatter) {
20182 #[derive(defmt :: Format)]
20183 struct Huffsymb6 {
20184 huff_symb_ram: u32,
20185 }
20186 let proxy = Huffsymb6 {
20187 huff_symb_ram: self.huff_symb_ram(),
20188 };
20189 defmt::write!(f, "{}", proxy)
20190 }
20191 }
20192 #[doc = "JPEG HUFFSYMB tables"]
20193 #[repr(transparent)]
20194 #[derive(Copy, Clone, Eq, PartialEq)]
20195 pub struct Huffsymb60(pub u32);
20196 impl Huffsymb60 {
20197 #[doc = "DHTSymb RAM"]
20198 #[inline(always)]
20199 pub const fn huff_symb_ram(&self) -> u32 {
20200 let val = (self.0 >> 0usize) & 0xffff_ffff;
20201 val as u32
20202 }
20203 #[doc = "DHTSymb RAM"]
20204 #[inline(always)]
20205 pub fn set_huff_symb_ram(&mut self, val: u32) {
20206 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20207 }
20208 }
20209 impl Default for Huffsymb60 {
20210 #[inline(always)]
20211 fn default() -> Huffsymb60 {
20212 Huffsymb60(0)
20213 }
20214 }
20215 impl core::fmt::Debug for Huffsymb60 {
20216 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20217 f.debug_struct("Huffsymb60")
20218 .field("huff_symb_ram", &self.huff_symb_ram())
20219 .finish()
20220 }
20221 }
20222 #[cfg(feature = "defmt")]
20223 impl defmt::Format for Huffsymb60 {
20224 fn format(&self, f: defmt::Formatter) {
20225 #[derive(defmt :: Format)]
20226 struct Huffsymb60 {
20227 huff_symb_ram: u32,
20228 }
20229 let proxy = Huffsymb60 {
20230 huff_symb_ram: self.huff_symb_ram(),
20231 };
20232 defmt::write!(f, "{}", proxy)
20233 }
20234 }
20235 #[doc = "JPEG HUFFSYMB tables"]
20236 #[repr(transparent)]
20237 #[derive(Copy, Clone, Eq, PartialEq)]
20238 pub struct Huffsymb61(pub u32);
20239 impl Huffsymb61 {
20240 #[doc = "DHTSymb RAM"]
20241 #[inline(always)]
20242 pub const fn huff_symb_ram(&self) -> u32 {
20243 let val = (self.0 >> 0usize) & 0xffff_ffff;
20244 val as u32
20245 }
20246 #[doc = "DHTSymb RAM"]
20247 #[inline(always)]
20248 pub fn set_huff_symb_ram(&mut self, val: u32) {
20249 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20250 }
20251 }
20252 impl Default for Huffsymb61 {
20253 #[inline(always)]
20254 fn default() -> Huffsymb61 {
20255 Huffsymb61(0)
20256 }
20257 }
20258 impl core::fmt::Debug for Huffsymb61 {
20259 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20260 f.debug_struct("Huffsymb61")
20261 .field("huff_symb_ram", &self.huff_symb_ram())
20262 .finish()
20263 }
20264 }
20265 #[cfg(feature = "defmt")]
20266 impl defmt::Format for Huffsymb61 {
20267 fn format(&self, f: defmt::Formatter) {
20268 #[derive(defmt :: Format)]
20269 struct Huffsymb61 {
20270 huff_symb_ram: u32,
20271 }
20272 let proxy = Huffsymb61 {
20273 huff_symb_ram: self.huff_symb_ram(),
20274 };
20275 defmt::write!(f, "{}", proxy)
20276 }
20277 }
20278 #[doc = "JPEG HUFFSYMB tables"]
20279 #[repr(transparent)]
20280 #[derive(Copy, Clone, Eq, PartialEq)]
20281 pub struct Huffsymb62(pub u32);
20282 impl Huffsymb62 {
20283 #[doc = "DHTSymb RAM"]
20284 #[inline(always)]
20285 pub const fn huff_symb_ram(&self) -> u32 {
20286 let val = (self.0 >> 0usize) & 0xffff_ffff;
20287 val as u32
20288 }
20289 #[doc = "DHTSymb RAM"]
20290 #[inline(always)]
20291 pub fn set_huff_symb_ram(&mut self, val: u32) {
20292 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20293 }
20294 }
20295 impl Default for Huffsymb62 {
20296 #[inline(always)]
20297 fn default() -> Huffsymb62 {
20298 Huffsymb62(0)
20299 }
20300 }
20301 impl core::fmt::Debug for Huffsymb62 {
20302 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20303 f.debug_struct("Huffsymb62")
20304 .field("huff_symb_ram", &self.huff_symb_ram())
20305 .finish()
20306 }
20307 }
20308 #[cfg(feature = "defmt")]
20309 impl defmt::Format for Huffsymb62 {
20310 fn format(&self, f: defmt::Formatter) {
20311 #[derive(defmt :: Format)]
20312 struct Huffsymb62 {
20313 huff_symb_ram: u32,
20314 }
20315 let proxy = Huffsymb62 {
20316 huff_symb_ram: self.huff_symb_ram(),
20317 };
20318 defmt::write!(f, "{}", proxy)
20319 }
20320 }
20321 #[doc = "JPEG HUFFSYMB tables"]
20322 #[repr(transparent)]
20323 #[derive(Copy, Clone, Eq, PartialEq)]
20324 pub struct Huffsymb63(pub u32);
20325 impl Huffsymb63 {
20326 #[doc = "DHTSymb RAM"]
20327 #[inline(always)]
20328 pub const fn huff_symb_ram(&self) -> u32 {
20329 let val = (self.0 >> 0usize) & 0xffff_ffff;
20330 val as u32
20331 }
20332 #[doc = "DHTSymb RAM"]
20333 #[inline(always)]
20334 pub fn set_huff_symb_ram(&mut self, val: u32) {
20335 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20336 }
20337 }
20338 impl Default for Huffsymb63 {
20339 #[inline(always)]
20340 fn default() -> Huffsymb63 {
20341 Huffsymb63(0)
20342 }
20343 }
20344 impl core::fmt::Debug for Huffsymb63 {
20345 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20346 f.debug_struct("Huffsymb63")
20347 .field("huff_symb_ram", &self.huff_symb_ram())
20348 .finish()
20349 }
20350 }
20351 #[cfg(feature = "defmt")]
20352 impl defmt::Format for Huffsymb63 {
20353 fn format(&self, f: defmt::Formatter) {
20354 #[derive(defmt :: Format)]
20355 struct Huffsymb63 {
20356 huff_symb_ram: u32,
20357 }
20358 let proxy = Huffsymb63 {
20359 huff_symb_ram: self.huff_symb_ram(),
20360 };
20361 defmt::write!(f, "{}", proxy)
20362 }
20363 }
20364 #[doc = "JPEG HUFFSYMB tables"]
20365 #[repr(transparent)]
20366 #[derive(Copy, Clone, Eq, PartialEq)]
20367 pub struct Huffsymb64(pub u32);
20368 impl Huffsymb64 {
20369 #[doc = "DHTSymb RAM"]
20370 #[inline(always)]
20371 pub const fn huff_symb_ram(&self) -> u32 {
20372 let val = (self.0 >> 0usize) & 0xffff_ffff;
20373 val as u32
20374 }
20375 #[doc = "DHTSymb RAM"]
20376 #[inline(always)]
20377 pub fn set_huff_symb_ram(&mut self, val: u32) {
20378 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20379 }
20380 }
20381 impl Default for Huffsymb64 {
20382 #[inline(always)]
20383 fn default() -> Huffsymb64 {
20384 Huffsymb64(0)
20385 }
20386 }
20387 impl core::fmt::Debug for Huffsymb64 {
20388 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20389 f.debug_struct("Huffsymb64")
20390 .field("huff_symb_ram", &self.huff_symb_ram())
20391 .finish()
20392 }
20393 }
20394 #[cfg(feature = "defmt")]
20395 impl defmt::Format for Huffsymb64 {
20396 fn format(&self, f: defmt::Formatter) {
20397 #[derive(defmt :: Format)]
20398 struct Huffsymb64 {
20399 huff_symb_ram: u32,
20400 }
20401 let proxy = Huffsymb64 {
20402 huff_symb_ram: self.huff_symb_ram(),
20403 };
20404 defmt::write!(f, "{}", proxy)
20405 }
20406 }
20407 #[doc = "JPEG HUFFSYMB tables"]
20408 #[repr(transparent)]
20409 #[derive(Copy, Clone, Eq, PartialEq)]
20410 pub struct Huffsymb65(pub u32);
20411 impl Huffsymb65 {
20412 #[doc = "DHTSymb RAM"]
20413 #[inline(always)]
20414 pub const fn huff_symb_ram(&self) -> u32 {
20415 let val = (self.0 >> 0usize) & 0xffff_ffff;
20416 val as u32
20417 }
20418 #[doc = "DHTSymb RAM"]
20419 #[inline(always)]
20420 pub fn set_huff_symb_ram(&mut self, val: u32) {
20421 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20422 }
20423 }
20424 impl Default for Huffsymb65 {
20425 #[inline(always)]
20426 fn default() -> Huffsymb65 {
20427 Huffsymb65(0)
20428 }
20429 }
20430 impl core::fmt::Debug for Huffsymb65 {
20431 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20432 f.debug_struct("Huffsymb65")
20433 .field("huff_symb_ram", &self.huff_symb_ram())
20434 .finish()
20435 }
20436 }
20437 #[cfg(feature = "defmt")]
20438 impl defmt::Format for Huffsymb65 {
20439 fn format(&self, f: defmt::Formatter) {
20440 #[derive(defmt :: Format)]
20441 struct Huffsymb65 {
20442 huff_symb_ram: u32,
20443 }
20444 let proxy = Huffsymb65 {
20445 huff_symb_ram: self.huff_symb_ram(),
20446 };
20447 defmt::write!(f, "{}", proxy)
20448 }
20449 }
20450 #[doc = "JPEG HUFFSYMB tables"]
20451 #[repr(transparent)]
20452 #[derive(Copy, Clone, Eq, PartialEq)]
20453 pub struct Huffsymb66(pub u32);
20454 impl Huffsymb66 {
20455 #[doc = "DHTSymb RAM"]
20456 #[inline(always)]
20457 pub const fn huff_symb_ram(&self) -> u32 {
20458 let val = (self.0 >> 0usize) & 0xffff_ffff;
20459 val as u32
20460 }
20461 #[doc = "DHTSymb RAM"]
20462 #[inline(always)]
20463 pub fn set_huff_symb_ram(&mut self, val: u32) {
20464 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20465 }
20466 }
20467 impl Default for Huffsymb66 {
20468 #[inline(always)]
20469 fn default() -> Huffsymb66 {
20470 Huffsymb66(0)
20471 }
20472 }
20473 impl core::fmt::Debug for Huffsymb66 {
20474 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20475 f.debug_struct("Huffsymb66")
20476 .field("huff_symb_ram", &self.huff_symb_ram())
20477 .finish()
20478 }
20479 }
20480 #[cfg(feature = "defmt")]
20481 impl defmt::Format for Huffsymb66 {
20482 fn format(&self, f: defmt::Formatter) {
20483 #[derive(defmt :: Format)]
20484 struct Huffsymb66 {
20485 huff_symb_ram: u32,
20486 }
20487 let proxy = Huffsymb66 {
20488 huff_symb_ram: self.huff_symb_ram(),
20489 };
20490 defmt::write!(f, "{}", proxy)
20491 }
20492 }
20493 #[doc = "JPEG HUFFSYMB tables"]
20494 #[repr(transparent)]
20495 #[derive(Copy, Clone, Eq, PartialEq)]
20496 pub struct Huffsymb67(pub u32);
20497 impl Huffsymb67 {
20498 #[doc = "DHTSymb RAM"]
20499 #[inline(always)]
20500 pub const fn huff_symb_ram(&self) -> u32 {
20501 let val = (self.0 >> 0usize) & 0xffff_ffff;
20502 val as u32
20503 }
20504 #[doc = "DHTSymb RAM"]
20505 #[inline(always)]
20506 pub fn set_huff_symb_ram(&mut self, val: u32) {
20507 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20508 }
20509 }
20510 impl Default for Huffsymb67 {
20511 #[inline(always)]
20512 fn default() -> Huffsymb67 {
20513 Huffsymb67(0)
20514 }
20515 }
20516 impl core::fmt::Debug for Huffsymb67 {
20517 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20518 f.debug_struct("Huffsymb67")
20519 .field("huff_symb_ram", &self.huff_symb_ram())
20520 .finish()
20521 }
20522 }
20523 #[cfg(feature = "defmt")]
20524 impl defmt::Format for Huffsymb67 {
20525 fn format(&self, f: defmt::Formatter) {
20526 #[derive(defmt :: Format)]
20527 struct Huffsymb67 {
20528 huff_symb_ram: u32,
20529 }
20530 let proxy = Huffsymb67 {
20531 huff_symb_ram: self.huff_symb_ram(),
20532 };
20533 defmt::write!(f, "{}", proxy)
20534 }
20535 }
20536 #[doc = "JPEG HUFFSYMB tables"]
20537 #[repr(transparent)]
20538 #[derive(Copy, Clone, Eq, PartialEq)]
20539 pub struct Huffsymb68(pub u32);
20540 impl Huffsymb68 {
20541 #[doc = "DHTSymb RAM"]
20542 #[inline(always)]
20543 pub const fn huff_symb_ram(&self) -> u32 {
20544 let val = (self.0 >> 0usize) & 0xffff_ffff;
20545 val as u32
20546 }
20547 #[doc = "DHTSymb RAM"]
20548 #[inline(always)]
20549 pub fn set_huff_symb_ram(&mut self, val: u32) {
20550 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20551 }
20552 }
20553 impl Default for Huffsymb68 {
20554 #[inline(always)]
20555 fn default() -> Huffsymb68 {
20556 Huffsymb68(0)
20557 }
20558 }
20559 impl core::fmt::Debug for Huffsymb68 {
20560 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20561 f.debug_struct("Huffsymb68")
20562 .field("huff_symb_ram", &self.huff_symb_ram())
20563 .finish()
20564 }
20565 }
20566 #[cfg(feature = "defmt")]
20567 impl defmt::Format for Huffsymb68 {
20568 fn format(&self, f: defmt::Formatter) {
20569 #[derive(defmt :: Format)]
20570 struct Huffsymb68 {
20571 huff_symb_ram: u32,
20572 }
20573 let proxy = Huffsymb68 {
20574 huff_symb_ram: self.huff_symb_ram(),
20575 };
20576 defmt::write!(f, "{}", proxy)
20577 }
20578 }
20579 #[doc = "JPEG HUFFSYMB tables"]
20580 #[repr(transparent)]
20581 #[derive(Copy, Clone, Eq, PartialEq)]
20582 pub struct Huffsymb69(pub u32);
20583 impl Huffsymb69 {
20584 #[doc = "DHTSymb RAM"]
20585 #[inline(always)]
20586 pub const fn huff_symb_ram(&self) -> u32 {
20587 let val = (self.0 >> 0usize) & 0xffff_ffff;
20588 val as u32
20589 }
20590 #[doc = "DHTSymb RAM"]
20591 #[inline(always)]
20592 pub fn set_huff_symb_ram(&mut self, val: u32) {
20593 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20594 }
20595 }
20596 impl Default for Huffsymb69 {
20597 #[inline(always)]
20598 fn default() -> Huffsymb69 {
20599 Huffsymb69(0)
20600 }
20601 }
20602 impl core::fmt::Debug for Huffsymb69 {
20603 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20604 f.debug_struct("Huffsymb69")
20605 .field("huff_symb_ram", &self.huff_symb_ram())
20606 .finish()
20607 }
20608 }
20609 #[cfg(feature = "defmt")]
20610 impl defmt::Format for Huffsymb69 {
20611 fn format(&self, f: defmt::Formatter) {
20612 #[derive(defmt :: Format)]
20613 struct Huffsymb69 {
20614 huff_symb_ram: u32,
20615 }
20616 let proxy = Huffsymb69 {
20617 huff_symb_ram: self.huff_symb_ram(),
20618 };
20619 defmt::write!(f, "{}", proxy)
20620 }
20621 }
20622 #[doc = "JPEG HUFFSYMB tables"]
20623 #[repr(transparent)]
20624 #[derive(Copy, Clone, Eq, PartialEq)]
20625 pub struct Huffsymb7(pub u32);
20626 impl Huffsymb7 {
20627 #[doc = "DHTSymb RAM"]
20628 #[inline(always)]
20629 pub const fn huff_symb_ram(&self) -> u32 {
20630 let val = (self.0 >> 0usize) & 0xffff_ffff;
20631 val as u32
20632 }
20633 #[doc = "DHTSymb RAM"]
20634 #[inline(always)]
20635 pub fn set_huff_symb_ram(&mut self, val: u32) {
20636 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20637 }
20638 }
20639 impl Default for Huffsymb7 {
20640 #[inline(always)]
20641 fn default() -> Huffsymb7 {
20642 Huffsymb7(0)
20643 }
20644 }
20645 impl core::fmt::Debug for Huffsymb7 {
20646 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20647 f.debug_struct("Huffsymb7")
20648 .field("huff_symb_ram", &self.huff_symb_ram())
20649 .finish()
20650 }
20651 }
20652 #[cfg(feature = "defmt")]
20653 impl defmt::Format for Huffsymb7 {
20654 fn format(&self, f: defmt::Formatter) {
20655 #[derive(defmt :: Format)]
20656 struct Huffsymb7 {
20657 huff_symb_ram: u32,
20658 }
20659 let proxy = Huffsymb7 {
20660 huff_symb_ram: self.huff_symb_ram(),
20661 };
20662 defmt::write!(f, "{}", proxy)
20663 }
20664 }
20665 #[doc = "JPEG HUFFSYMB tables"]
20666 #[repr(transparent)]
20667 #[derive(Copy, Clone, Eq, PartialEq)]
20668 pub struct Huffsymb70(pub u32);
20669 impl Huffsymb70 {
20670 #[doc = "DHTSymb RAM"]
20671 #[inline(always)]
20672 pub const fn huff_symb_ram(&self) -> u32 {
20673 let val = (self.0 >> 0usize) & 0xffff_ffff;
20674 val as u32
20675 }
20676 #[doc = "DHTSymb RAM"]
20677 #[inline(always)]
20678 pub fn set_huff_symb_ram(&mut self, val: u32) {
20679 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20680 }
20681 }
20682 impl Default for Huffsymb70 {
20683 #[inline(always)]
20684 fn default() -> Huffsymb70 {
20685 Huffsymb70(0)
20686 }
20687 }
20688 impl core::fmt::Debug for Huffsymb70 {
20689 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20690 f.debug_struct("Huffsymb70")
20691 .field("huff_symb_ram", &self.huff_symb_ram())
20692 .finish()
20693 }
20694 }
20695 #[cfg(feature = "defmt")]
20696 impl defmt::Format for Huffsymb70 {
20697 fn format(&self, f: defmt::Formatter) {
20698 #[derive(defmt :: Format)]
20699 struct Huffsymb70 {
20700 huff_symb_ram: u32,
20701 }
20702 let proxy = Huffsymb70 {
20703 huff_symb_ram: self.huff_symb_ram(),
20704 };
20705 defmt::write!(f, "{}", proxy)
20706 }
20707 }
20708 #[doc = "JPEG HUFFSYMB tables"]
20709 #[repr(transparent)]
20710 #[derive(Copy, Clone, Eq, PartialEq)]
20711 pub struct Huffsymb71(pub u32);
20712 impl Huffsymb71 {
20713 #[doc = "DHTSymb RAM"]
20714 #[inline(always)]
20715 pub const fn huff_symb_ram(&self) -> u32 {
20716 let val = (self.0 >> 0usize) & 0xffff_ffff;
20717 val as u32
20718 }
20719 #[doc = "DHTSymb RAM"]
20720 #[inline(always)]
20721 pub fn set_huff_symb_ram(&mut self, val: u32) {
20722 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20723 }
20724 }
20725 impl Default for Huffsymb71 {
20726 #[inline(always)]
20727 fn default() -> Huffsymb71 {
20728 Huffsymb71(0)
20729 }
20730 }
20731 impl core::fmt::Debug for Huffsymb71 {
20732 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20733 f.debug_struct("Huffsymb71")
20734 .field("huff_symb_ram", &self.huff_symb_ram())
20735 .finish()
20736 }
20737 }
20738 #[cfg(feature = "defmt")]
20739 impl defmt::Format for Huffsymb71 {
20740 fn format(&self, f: defmt::Formatter) {
20741 #[derive(defmt :: Format)]
20742 struct Huffsymb71 {
20743 huff_symb_ram: u32,
20744 }
20745 let proxy = Huffsymb71 {
20746 huff_symb_ram: self.huff_symb_ram(),
20747 };
20748 defmt::write!(f, "{}", proxy)
20749 }
20750 }
20751 #[doc = "JPEG HUFFSYMB tables"]
20752 #[repr(transparent)]
20753 #[derive(Copy, Clone, Eq, PartialEq)]
20754 pub struct Huffsymb72(pub u32);
20755 impl Huffsymb72 {
20756 #[doc = "DHTSymb RAM"]
20757 #[inline(always)]
20758 pub const fn huff_symb_ram(&self) -> u32 {
20759 let val = (self.0 >> 0usize) & 0xffff_ffff;
20760 val as u32
20761 }
20762 #[doc = "DHTSymb RAM"]
20763 #[inline(always)]
20764 pub fn set_huff_symb_ram(&mut self, val: u32) {
20765 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20766 }
20767 }
20768 impl Default for Huffsymb72 {
20769 #[inline(always)]
20770 fn default() -> Huffsymb72 {
20771 Huffsymb72(0)
20772 }
20773 }
20774 impl core::fmt::Debug for Huffsymb72 {
20775 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20776 f.debug_struct("Huffsymb72")
20777 .field("huff_symb_ram", &self.huff_symb_ram())
20778 .finish()
20779 }
20780 }
20781 #[cfg(feature = "defmt")]
20782 impl defmt::Format for Huffsymb72 {
20783 fn format(&self, f: defmt::Formatter) {
20784 #[derive(defmt :: Format)]
20785 struct Huffsymb72 {
20786 huff_symb_ram: u32,
20787 }
20788 let proxy = Huffsymb72 {
20789 huff_symb_ram: self.huff_symb_ram(),
20790 };
20791 defmt::write!(f, "{}", proxy)
20792 }
20793 }
20794 #[doc = "JPEG HUFFSYMB tables"]
20795 #[repr(transparent)]
20796 #[derive(Copy, Clone, Eq, PartialEq)]
20797 pub struct Huffsymb73(pub u32);
20798 impl Huffsymb73 {
20799 #[doc = "DHTSymb RAM"]
20800 #[inline(always)]
20801 pub const fn huff_symb_ram(&self) -> u32 {
20802 let val = (self.0 >> 0usize) & 0xffff_ffff;
20803 val as u32
20804 }
20805 #[doc = "DHTSymb RAM"]
20806 #[inline(always)]
20807 pub fn set_huff_symb_ram(&mut self, val: u32) {
20808 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20809 }
20810 }
20811 impl Default for Huffsymb73 {
20812 #[inline(always)]
20813 fn default() -> Huffsymb73 {
20814 Huffsymb73(0)
20815 }
20816 }
20817 impl core::fmt::Debug for Huffsymb73 {
20818 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20819 f.debug_struct("Huffsymb73")
20820 .field("huff_symb_ram", &self.huff_symb_ram())
20821 .finish()
20822 }
20823 }
20824 #[cfg(feature = "defmt")]
20825 impl defmt::Format for Huffsymb73 {
20826 fn format(&self, f: defmt::Formatter) {
20827 #[derive(defmt :: Format)]
20828 struct Huffsymb73 {
20829 huff_symb_ram: u32,
20830 }
20831 let proxy = Huffsymb73 {
20832 huff_symb_ram: self.huff_symb_ram(),
20833 };
20834 defmt::write!(f, "{}", proxy)
20835 }
20836 }
20837 #[doc = "JPEG HUFFSYMB tables"]
20838 #[repr(transparent)]
20839 #[derive(Copy, Clone, Eq, PartialEq)]
20840 pub struct Huffsymb74(pub u32);
20841 impl Huffsymb74 {
20842 #[doc = "DHTSymb RAM"]
20843 #[inline(always)]
20844 pub const fn huff_symb_ram(&self) -> u32 {
20845 let val = (self.0 >> 0usize) & 0xffff_ffff;
20846 val as u32
20847 }
20848 #[doc = "DHTSymb RAM"]
20849 #[inline(always)]
20850 pub fn set_huff_symb_ram(&mut self, val: u32) {
20851 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20852 }
20853 }
20854 impl Default for Huffsymb74 {
20855 #[inline(always)]
20856 fn default() -> Huffsymb74 {
20857 Huffsymb74(0)
20858 }
20859 }
20860 impl core::fmt::Debug for Huffsymb74 {
20861 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20862 f.debug_struct("Huffsymb74")
20863 .field("huff_symb_ram", &self.huff_symb_ram())
20864 .finish()
20865 }
20866 }
20867 #[cfg(feature = "defmt")]
20868 impl defmt::Format for Huffsymb74 {
20869 fn format(&self, f: defmt::Formatter) {
20870 #[derive(defmt :: Format)]
20871 struct Huffsymb74 {
20872 huff_symb_ram: u32,
20873 }
20874 let proxy = Huffsymb74 {
20875 huff_symb_ram: self.huff_symb_ram(),
20876 };
20877 defmt::write!(f, "{}", proxy)
20878 }
20879 }
20880 #[doc = "JPEG HUFFSYMB tables"]
20881 #[repr(transparent)]
20882 #[derive(Copy, Clone, Eq, PartialEq)]
20883 pub struct Huffsymb75(pub u32);
20884 impl Huffsymb75 {
20885 #[doc = "DHTSymb RAM"]
20886 #[inline(always)]
20887 pub const fn huff_symb_ram(&self) -> u32 {
20888 let val = (self.0 >> 0usize) & 0xffff_ffff;
20889 val as u32
20890 }
20891 #[doc = "DHTSymb RAM"]
20892 #[inline(always)]
20893 pub fn set_huff_symb_ram(&mut self, val: u32) {
20894 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20895 }
20896 }
20897 impl Default for Huffsymb75 {
20898 #[inline(always)]
20899 fn default() -> Huffsymb75 {
20900 Huffsymb75(0)
20901 }
20902 }
20903 impl core::fmt::Debug for Huffsymb75 {
20904 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20905 f.debug_struct("Huffsymb75")
20906 .field("huff_symb_ram", &self.huff_symb_ram())
20907 .finish()
20908 }
20909 }
20910 #[cfg(feature = "defmt")]
20911 impl defmt::Format for Huffsymb75 {
20912 fn format(&self, f: defmt::Formatter) {
20913 #[derive(defmt :: Format)]
20914 struct Huffsymb75 {
20915 huff_symb_ram: u32,
20916 }
20917 let proxy = Huffsymb75 {
20918 huff_symb_ram: self.huff_symb_ram(),
20919 };
20920 defmt::write!(f, "{}", proxy)
20921 }
20922 }
20923 #[doc = "JPEG HUFFSYMB tables"]
20924 #[repr(transparent)]
20925 #[derive(Copy, Clone, Eq, PartialEq)]
20926 pub struct Huffsymb76(pub u32);
20927 impl Huffsymb76 {
20928 #[doc = "DHTSymb RAM"]
20929 #[inline(always)]
20930 pub const fn huff_symb_ram(&self) -> u32 {
20931 let val = (self.0 >> 0usize) & 0xffff_ffff;
20932 val as u32
20933 }
20934 #[doc = "DHTSymb RAM"]
20935 #[inline(always)]
20936 pub fn set_huff_symb_ram(&mut self, val: u32) {
20937 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20938 }
20939 }
20940 impl Default for Huffsymb76 {
20941 #[inline(always)]
20942 fn default() -> Huffsymb76 {
20943 Huffsymb76(0)
20944 }
20945 }
20946 impl core::fmt::Debug for Huffsymb76 {
20947 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20948 f.debug_struct("Huffsymb76")
20949 .field("huff_symb_ram", &self.huff_symb_ram())
20950 .finish()
20951 }
20952 }
20953 #[cfg(feature = "defmt")]
20954 impl defmt::Format for Huffsymb76 {
20955 fn format(&self, f: defmt::Formatter) {
20956 #[derive(defmt :: Format)]
20957 struct Huffsymb76 {
20958 huff_symb_ram: u32,
20959 }
20960 let proxy = Huffsymb76 {
20961 huff_symb_ram: self.huff_symb_ram(),
20962 };
20963 defmt::write!(f, "{}", proxy)
20964 }
20965 }
20966 #[doc = "JPEG HUFFSYMB tables"]
20967 #[repr(transparent)]
20968 #[derive(Copy, Clone, Eq, PartialEq)]
20969 pub struct Huffsymb77(pub u32);
20970 impl Huffsymb77 {
20971 #[doc = "DHTSymb RAM"]
20972 #[inline(always)]
20973 pub const fn huff_symb_ram(&self) -> u32 {
20974 let val = (self.0 >> 0usize) & 0xffff_ffff;
20975 val as u32
20976 }
20977 #[doc = "DHTSymb RAM"]
20978 #[inline(always)]
20979 pub fn set_huff_symb_ram(&mut self, val: u32) {
20980 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
20981 }
20982 }
20983 impl Default for Huffsymb77 {
20984 #[inline(always)]
20985 fn default() -> Huffsymb77 {
20986 Huffsymb77(0)
20987 }
20988 }
20989 impl core::fmt::Debug for Huffsymb77 {
20990 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
20991 f.debug_struct("Huffsymb77")
20992 .field("huff_symb_ram", &self.huff_symb_ram())
20993 .finish()
20994 }
20995 }
20996 #[cfg(feature = "defmt")]
20997 impl defmt::Format for Huffsymb77 {
20998 fn format(&self, f: defmt::Formatter) {
20999 #[derive(defmt :: Format)]
21000 struct Huffsymb77 {
21001 huff_symb_ram: u32,
21002 }
21003 let proxy = Huffsymb77 {
21004 huff_symb_ram: self.huff_symb_ram(),
21005 };
21006 defmt::write!(f, "{}", proxy)
21007 }
21008 }
21009 #[doc = "JPEG HUFFSYMB tables"]
21010 #[repr(transparent)]
21011 #[derive(Copy, Clone, Eq, PartialEq)]
21012 pub struct Huffsymb78(pub u32);
21013 impl Huffsymb78 {
21014 #[doc = "DHTSymb RAM"]
21015 #[inline(always)]
21016 pub const fn huff_symb_ram(&self) -> u32 {
21017 let val = (self.0 >> 0usize) & 0xffff_ffff;
21018 val as u32
21019 }
21020 #[doc = "DHTSymb RAM"]
21021 #[inline(always)]
21022 pub fn set_huff_symb_ram(&mut self, val: u32) {
21023 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
21024 }
21025 }
21026 impl Default for Huffsymb78 {
21027 #[inline(always)]
21028 fn default() -> Huffsymb78 {
21029 Huffsymb78(0)
21030 }
21031 }
21032 impl core::fmt::Debug for Huffsymb78 {
21033 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21034 f.debug_struct("Huffsymb78")
21035 .field("huff_symb_ram", &self.huff_symb_ram())
21036 .finish()
21037 }
21038 }
21039 #[cfg(feature = "defmt")]
21040 impl defmt::Format for Huffsymb78 {
21041 fn format(&self, f: defmt::Formatter) {
21042 #[derive(defmt :: Format)]
21043 struct Huffsymb78 {
21044 huff_symb_ram: u32,
21045 }
21046 let proxy = Huffsymb78 {
21047 huff_symb_ram: self.huff_symb_ram(),
21048 };
21049 defmt::write!(f, "{}", proxy)
21050 }
21051 }
21052 #[doc = "JPEG HUFFSYMB tables"]
21053 #[repr(transparent)]
21054 #[derive(Copy, Clone, Eq, PartialEq)]
21055 pub struct Huffsymb79(pub u32);
21056 impl Huffsymb79 {
21057 #[doc = "DHTSymb RAM"]
21058 #[inline(always)]
21059 pub const fn huff_symb_ram(&self) -> u32 {
21060 let val = (self.0 >> 0usize) & 0xffff_ffff;
21061 val as u32
21062 }
21063 #[doc = "DHTSymb RAM"]
21064 #[inline(always)]
21065 pub fn set_huff_symb_ram(&mut self, val: u32) {
21066 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
21067 }
21068 }
21069 impl Default for Huffsymb79 {
21070 #[inline(always)]
21071 fn default() -> Huffsymb79 {
21072 Huffsymb79(0)
21073 }
21074 }
21075 impl core::fmt::Debug for Huffsymb79 {
21076 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21077 f.debug_struct("Huffsymb79")
21078 .field("huff_symb_ram", &self.huff_symb_ram())
21079 .finish()
21080 }
21081 }
21082 #[cfg(feature = "defmt")]
21083 impl defmt::Format for Huffsymb79 {
21084 fn format(&self, f: defmt::Formatter) {
21085 #[derive(defmt :: Format)]
21086 struct Huffsymb79 {
21087 huff_symb_ram: u32,
21088 }
21089 let proxy = Huffsymb79 {
21090 huff_symb_ram: self.huff_symb_ram(),
21091 };
21092 defmt::write!(f, "{}", proxy)
21093 }
21094 }
21095 #[doc = "JPEG HUFFSYMB tables"]
21096 #[repr(transparent)]
21097 #[derive(Copy, Clone, Eq, PartialEq)]
21098 pub struct Huffsymb8(pub u32);
21099 impl Huffsymb8 {
21100 #[doc = "DHTSymb RAM"]
21101 #[inline(always)]
21102 pub const fn huff_symb_ram(&self) -> u32 {
21103 let val = (self.0 >> 0usize) & 0xffff_ffff;
21104 val as u32
21105 }
21106 #[doc = "DHTSymb RAM"]
21107 #[inline(always)]
21108 pub fn set_huff_symb_ram(&mut self, val: u32) {
21109 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
21110 }
21111 }
21112 impl Default for Huffsymb8 {
21113 #[inline(always)]
21114 fn default() -> Huffsymb8 {
21115 Huffsymb8(0)
21116 }
21117 }
21118 impl core::fmt::Debug for Huffsymb8 {
21119 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21120 f.debug_struct("Huffsymb8")
21121 .field("huff_symb_ram", &self.huff_symb_ram())
21122 .finish()
21123 }
21124 }
21125 #[cfg(feature = "defmt")]
21126 impl defmt::Format for Huffsymb8 {
21127 fn format(&self, f: defmt::Formatter) {
21128 #[derive(defmt :: Format)]
21129 struct Huffsymb8 {
21130 huff_symb_ram: u32,
21131 }
21132 let proxy = Huffsymb8 {
21133 huff_symb_ram: self.huff_symb_ram(),
21134 };
21135 defmt::write!(f, "{}", proxy)
21136 }
21137 }
21138 #[doc = "JPEG HUFFSYMB tables"]
21139 #[repr(transparent)]
21140 #[derive(Copy, Clone, Eq, PartialEq)]
21141 pub struct Huffsymb80(pub u32);
21142 impl Huffsymb80 {
21143 #[doc = "DHTSymb RAM"]
21144 #[inline(always)]
21145 pub const fn huff_symb_ram(&self) -> u32 {
21146 let val = (self.0 >> 0usize) & 0xffff_ffff;
21147 val as u32
21148 }
21149 #[doc = "DHTSymb RAM"]
21150 #[inline(always)]
21151 pub fn set_huff_symb_ram(&mut self, val: u32) {
21152 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
21153 }
21154 }
21155 impl Default for Huffsymb80 {
21156 #[inline(always)]
21157 fn default() -> Huffsymb80 {
21158 Huffsymb80(0)
21159 }
21160 }
21161 impl core::fmt::Debug for Huffsymb80 {
21162 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21163 f.debug_struct("Huffsymb80")
21164 .field("huff_symb_ram", &self.huff_symb_ram())
21165 .finish()
21166 }
21167 }
21168 #[cfg(feature = "defmt")]
21169 impl defmt::Format for Huffsymb80 {
21170 fn format(&self, f: defmt::Formatter) {
21171 #[derive(defmt :: Format)]
21172 struct Huffsymb80 {
21173 huff_symb_ram: u32,
21174 }
21175 let proxy = Huffsymb80 {
21176 huff_symb_ram: self.huff_symb_ram(),
21177 };
21178 defmt::write!(f, "{}", proxy)
21179 }
21180 }
21181 #[doc = "JPEG HUFFSYMB tables"]
21182 #[repr(transparent)]
21183 #[derive(Copy, Clone, Eq, PartialEq)]
21184 pub struct Huffsymb81(pub u32);
21185 impl Huffsymb81 {
21186 #[doc = "DHTSymb RAM"]
21187 #[inline(always)]
21188 pub const fn huff_symb_ram(&self) -> u32 {
21189 let val = (self.0 >> 0usize) & 0xffff_ffff;
21190 val as u32
21191 }
21192 #[doc = "DHTSymb RAM"]
21193 #[inline(always)]
21194 pub fn set_huff_symb_ram(&mut self, val: u32) {
21195 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
21196 }
21197 }
21198 impl Default for Huffsymb81 {
21199 #[inline(always)]
21200 fn default() -> Huffsymb81 {
21201 Huffsymb81(0)
21202 }
21203 }
21204 impl core::fmt::Debug for Huffsymb81 {
21205 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21206 f.debug_struct("Huffsymb81")
21207 .field("huff_symb_ram", &self.huff_symb_ram())
21208 .finish()
21209 }
21210 }
21211 #[cfg(feature = "defmt")]
21212 impl defmt::Format for Huffsymb81 {
21213 fn format(&self, f: defmt::Formatter) {
21214 #[derive(defmt :: Format)]
21215 struct Huffsymb81 {
21216 huff_symb_ram: u32,
21217 }
21218 let proxy = Huffsymb81 {
21219 huff_symb_ram: self.huff_symb_ram(),
21220 };
21221 defmt::write!(f, "{}", proxy)
21222 }
21223 }
21224 #[doc = "JPEG HUFFSYMB tables"]
21225 #[repr(transparent)]
21226 #[derive(Copy, Clone, Eq, PartialEq)]
21227 pub struct Huffsymb82(pub u32);
21228 impl Huffsymb82 {
21229 #[doc = "DHTSymb RAM"]
21230 #[inline(always)]
21231 pub const fn huff_symb_ram(&self) -> u32 {
21232 let val = (self.0 >> 0usize) & 0xffff_ffff;
21233 val as u32
21234 }
21235 #[doc = "DHTSymb RAM"]
21236 #[inline(always)]
21237 pub fn set_huff_symb_ram(&mut self, val: u32) {
21238 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
21239 }
21240 }
21241 impl Default for Huffsymb82 {
21242 #[inline(always)]
21243 fn default() -> Huffsymb82 {
21244 Huffsymb82(0)
21245 }
21246 }
21247 impl core::fmt::Debug for Huffsymb82 {
21248 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21249 f.debug_struct("Huffsymb82")
21250 .field("huff_symb_ram", &self.huff_symb_ram())
21251 .finish()
21252 }
21253 }
21254 #[cfg(feature = "defmt")]
21255 impl defmt::Format for Huffsymb82 {
21256 fn format(&self, f: defmt::Formatter) {
21257 #[derive(defmt :: Format)]
21258 struct Huffsymb82 {
21259 huff_symb_ram: u32,
21260 }
21261 let proxy = Huffsymb82 {
21262 huff_symb_ram: self.huff_symb_ram(),
21263 };
21264 defmt::write!(f, "{}", proxy)
21265 }
21266 }
21267 #[doc = "JPEG HUFFSYMB tables"]
21268 #[repr(transparent)]
21269 #[derive(Copy, Clone, Eq, PartialEq)]
21270 pub struct Huffsymb83(pub u32);
21271 impl Huffsymb83 {
21272 #[doc = "DHTSymb RAM"]
21273 #[inline(always)]
21274 pub const fn huff_symb_ram(&self) -> u32 {
21275 let val = (self.0 >> 0usize) & 0xffff_ffff;
21276 val as u32
21277 }
21278 #[doc = "DHTSymb RAM"]
21279 #[inline(always)]
21280 pub fn set_huff_symb_ram(&mut self, val: u32) {
21281 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
21282 }
21283 }
21284 impl Default for Huffsymb83 {
21285 #[inline(always)]
21286 fn default() -> Huffsymb83 {
21287 Huffsymb83(0)
21288 }
21289 }
21290 impl core::fmt::Debug for Huffsymb83 {
21291 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21292 f.debug_struct("Huffsymb83")
21293 .field("huff_symb_ram", &self.huff_symb_ram())
21294 .finish()
21295 }
21296 }
21297 #[cfg(feature = "defmt")]
21298 impl defmt::Format for Huffsymb83 {
21299 fn format(&self, f: defmt::Formatter) {
21300 #[derive(defmt :: Format)]
21301 struct Huffsymb83 {
21302 huff_symb_ram: u32,
21303 }
21304 let proxy = Huffsymb83 {
21305 huff_symb_ram: self.huff_symb_ram(),
21306 };
21307 defmt::write!(f, "{}", proxy)
21308 }
21309 }
21310 #[doc = "JPEG HUFFSYMB tables"]
21311 #[repr(transparent)]
21312 #[derive(Copy, Clone, Eq, PartialEq)]
21313 pub struct Huffsymb9(pub u32);
21314 impl Huffsymb9 {
21315 #[doc = "DHTSymb RAM"]
21316 #[inline(always)]
21317 pub const fn huff_symb_ram(&self) -> u32 {
21318 let val = (self.0 >> 0usize) & 0xffff_ffff;
21319 val as u32
21320 }
21321 #[doc = "DHTSymb RAM"]
21322 #[inline(always)]
21323 pub fn set_huff_symb_ram(&mut self, val: u32) {
21324 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
21325 }
21326 }
21327 impl Default for Huffsymb9 {
21328 #[inline(always)]
21329 fn default() -> Huffsymb9 {
21330 Huffsymb9(0)
21331 }
21332 }
21333 impl core::fmt::Debug for Huffsymb9 {
21334 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21335 f.debug_struct("Huffsymb9")
21336 .field("huff_symb_ram", &self.huff_symb_ram())
21337 .finish()
21338 }
21339 }
21340 #[cfg(feature = "defmt")]
21341 impl defmt::Format for Huffsymb9 {
21342 fn format(&self, f: defmt::Formatter) {
21343 #[derive(defmt :: Format)]
21344 struct Huffsymb9 {
21345 huff_symb_ram: u32,
21346 }
21347 let proxy = Huffsymb9 {
21348 huff_symb_ram: self.huff_symb_ram(),
21349 };
21350 defmt::write!(f, "{}", proxy)
21351 }
21352 }
21353 #[doc = "JPEG clear flag register"]
21354 #[repr(transparent)]
21355 #[derive(Copy, Clone, Eq, PartialEq)]
21356 pub struct JpegCfr(pub u32);
21357 impl JpegCfr {
21358 #[doc = "Clear End of Conversion Flag"]
21359 #[inline(always)]
21360 pub const fn ceocf(&self) -> bool {
21361 let val = (self.0 >> 5usize) & 0x01;
21362 val != 0
21363 }
21364 #[doc = "Clear End of Conversion Flag"]
21365 #[inline(always)]
21366 pub fn set_ceocf(&mut self, val: bool) {
21367 self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
21368 }
21369 #[doc = "Clear Header Parsing Done Flag"]
21370 #[inline(always)]
21371 pub const fn chpdf(&self) -> bool {
21372 let val = (self.0 >> 6usize) & 0x01;
21373 val != 0
21374 }
21375 #[doc = "Clear Header Parsing Done Flag"]
21376 #[inline(always)]
21377 pub fn set_chpdf(&mut self, val: bool) {
21378 self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
21379 }
21380 }
21381 impl Default for JpegCfr {
21382 #[inline(always)]
21383 fn default() -> JpegCfr {
21384 JpegCfr(0)
21385 }
21386 }
21387 impl core::fmt::Debug for JpegCfr {
21388 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21389 f.debug_struct("JpegCfr")
21390 .field("ceocf", &self.ceocf())
21391 .field("chpdf", &self.chpdf())
21392 .finish()
21393 }
21394 }
21395 #[cfg(feature = "defmt")]
21396 impl defmt::Format for JpegCfr {
21397 fn format(&self, f: defmt::Formatter) {
21398 #[derive(defmt :: Format)]
21399 struct JpegCfr {
21400 ceocf: bool,
21401 chpdf: bool,
21402 }
21403 let proxy = JpegCfr {
21404 ceocf: self.ceocf(),
21405 chpdf: self.chpdf(),
21406 };
21407 defmt::write!(f, "{}", proxy)
21408 }
21409 }
21410 #[doc = "JPEG codec configuration register 0"]
21411 #[repr(transparent)]
21412 #[derive(Copy, Clone, Eq, PartialEq)]
21413 pub struct JpegConfr0(pub u32);
21414 impl JpegConfr0 {
21415 #[doc = "Start"]
21416 #[inline(always)]
21417 pub const fn start(&self) -> bool {
21418 let val = (self.0 >> 0usize) & 0x01;
21419 val != 0
21420 }
21421 #[doc = "Start"]
21422 #[inline(always)]
21423 pub fn set_start(&mut self, val: bool) {
21424 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
21425 }
21426 }
21427 impl Default for JpegConfr0 {
21428 #[inline(always)]
21429 fn default() -> JpegConfr0 {
21430 JpegConfr0(0)
21431 }
21432 }
21433 impl core::fmt::Debug for JpegConfr0 {
21434 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21435 f.debug_struct("JpegConfr0").field("start", &self.start()).finish()
21436 }
21437 }
21438 #[cfg(feature = "defmt")]
21439 impl defmt::Format for JpegConfr0 {
21440 fn format(&self, f: defmt::Formatter) {
21441 #[derive(defmt :: Format)]
21442 struct JpegConfr0 {
21443 start: bool,
21444 }
21445 let proxy = JpegConfr0 { start: self.start() };
21446 defmt::write!(f, "{}", proxy)
21447 }
21448 }
21449 #[doc = "JPEG codec configuration register 1"]
21450 #[repr(transparent)]
21451 #[derive(Copy, Clone, Eq, PartialEq)]
21452 pub struct JpegConfr1(pub u32);
21453 impl JpegConfr1 {
21454 #[doc = "Number of color components"]
21455 #[inline(always)]
21456 pub const fn nf(&self) -> u8 {
21457 let val = (self.0 >> 0usize) & 0x03;
21458 val as u8
21459 }
21460 #[doc = "Number of color components"]
21461 #[inline(always)]
21462 pub fn set_nf(&mut self, val: u8) {
21463 self.0 = (self.0 & !(0x03 << 0usize)) | (((val as u32) & 0x03) << 0usize);
21464 }
21465 #[doc = "Decoding Enable"]
21466 #[inline(always)]
21467 pub const fn de(&self) -> bool {
21468 let val = (self.0 >> 3usize) & 0x01;
21469 val != 0
21470 }
21471 #[doc = "Decoding Enable"]
21472 #[inline(always)]
21473 pub fn set_de(&mut self, val: bool) {
21474 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
21475 }
21476 #[doc = "Color Space"]
21477 #[inline(always)]
21478 pub const fn colorspace(&self) -> u8 {
21479 let val = (self.0 >> 4usize) & 0x03;
21480 val as u8
21481 }
21482 #[doc = "Color Space"]
21483 #[inline(always)]
21484 pub fn set_colorspace(&mut self, val: u8) {
21485 self.0 = (self.0 & !(0x03 << 4usize)) | (((val as u32) & 0x03) << 4usize);
21486 }
21487 #[doc = "Number of components for Scan"]
21488 #[inline(always)]
21489 pub const fn ns(&self) -> u8 {
21490 let val = (self.0 >> 6usize) & 0x03;
21491 val as u8
21492 }
21493 #[doc = "Number of components for Scan"]
21494 #[inline(always)]
21495 pub fn set_ns(&mut self, val: u8) {
21496 self.0 = (self.0 & !(0x03 << 6usize)) | (((val as u32) & 0x03) << 6usize);
21497 }
21498 #[doc = "Header Processing"]
21499 #[inline(always)]
21500 pub const fn hdr(&self) -> bool {
21501 let val = (self.0 >> 8usize) & 0x01;
21502 val != 0
21503 }
21504 #[doc = "Header Processing"]
21505 #[inline(always)]
21506 pub fn set_hdr(&mut self, val: bool) {
21507 self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
21508 }
21509 #[doc = "Y Size"]
21510 #[inline(always)]
21511 pub const fn ysize(&self) -> u16 {
21512 let val = (self.0 >> 16usize) & 0xffff;
21513 val as u16
21514 }
21515 #[doc = "Y Size"]
21516 #[inline(always)]
21517 pub fn set_ysize(&mut self, val: u16) {
21518 self.0 = (self.0 & !(0xffff << 16usize)) | (((val as u32) & 0xffff) << 16usize);
21519 }
21520 }
21521 impl Default for JpegConfr1 {
21522 #[inline(always)]
21523 fn default() -> JpegConfr1 {
21524 JpegConfr1(0)
21525 }
21526 }
21527 impl core::fmt::Debug for JpegConfr1 {
21528 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21529 f.debug_struct("JpegConfr1")
21530 .field("nf", &self.nf())
21531 .field("de", &self.de())
21532 .field("colorspace", &self.colorspace())
21533 .field("ns", &self.ns())
21534 .field("hdr", &self.hdr())
21535 .field("ysize", &self.ysize())
21536 .finish()
21537 }
21538 }
21539 #[cfg(feature = "defmt")]
21540 impl defmt::Format for JpegConfr1 {
21541 fn format(&self, f: defmt::Formatter) {
21542 #[derive(defmt :: Format)]
21543 struct JpegConfr1 {
21544 nf: u8,
21545 de: bool,
21546 colorspace: u8,
21547 ns: u8,
21548 hdr: bool,
21549 ysize: u16,
21550 }
21551 let proxy = JpegConfr1 {
21552 nf: self.nf(),
21553 de: self.de(),
21554 colorspace: self.colorspace(),
21555 ns: self.ns(),
21556 hdr: self.hdr(),
21557 ysize: self.ysize(),
21558 };
21559 defmt::write!(f, "{}", proxy)
21560 }
21561 }
21562 #[doc = "JPEG codec configuration register 2"]
21563 #[repr(transparent)]
21564 #[derive(Copy, Clone, Eq, PartialEq)]
21565 pub struct JpegConfr2(pub u32);
21566 impl JpegConfr2 {
21567 #[doc = "Number of MCU"]
21568 #[inline(always)]
21569 pub const fn nmcu(&self) -> u32 {
21570 let val = (self.0 >> 0usize) & 0x03ff_ffff;
21571 val as u32
21572 }
21573 #[doc = "Number of MCU"]
21574 #[inline(always)]
21575 pub fn set_nmcu(&mut self, val: u32) {
21576 self.0 = (self.0 & !(0x03ff_ffff << 0usize)) | (((val as u32) & 0x03ff_ffff) << 0usize);
21577 }
21578 }
21579 impl Default for JpegConfr2 {
21580 #[inline(always)]
21581 fn default() -> JpegConfr2 {
21582 JpegConfr2(0)
21583 }
21584 }
21585 impl core::fmt::Debug for JpegConfr2 {
21586 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21587 f.debug_struct("JpegConfr2").field("nmcu", &self.nmcu()).finish()
21588 }
21589 }
21590 #[cfg(feature = "defmt")]
21591 impl defmt::Format for JpegConfr2 {
21592 fn format(&self, f: defmt::Formatter) {
21593 #[derive(defmt :: Format)]
21594 struct JpegConfr2 {
21595 nmcu: u32,
21596 }
21597 let proxy = JpegConfr2 { nmcu: self.nmcu() };
21598 defmt::write!(f, "{}", proxy)
21599 }
21600 }
21601 #[doc = "JPEG codec configuration register 3"]
21602 #[repr(transparent)]
21603 #[derive(Copy, Clone, Eq, PartialEq)]
21604 pub struct JpegConfr3(pub u32);
21605 impl JpegConfr3 {
21606 #[doc = "X size"]
21607 #[inline(always)]
21608 pub const fn xsize(&self) -> u16 {
21609 let val = (self.0 >> 16usize) & 0xffff;
21610 val as u16
21611 }
21612 #[doc = "X size"]
21613 #[inline(always)]
21614 pub fn set_xsize(&mut self, val: u16) {
21615 self.0 = (self.0 & !(0xffff << 16usize)) | (((val as u32) & 0xffff) << 16usize);
21616 }
21617 }
21618 impl Default for JpegConfr3 {
21619 #[inline(always)]
21620 fn default() -> JpegConfr3 {
21621 JpegConfr3(0)
21622 }
21623 }
21624 impl core::fmt::Debug for JpegConfr3 {
21625 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21626 f.debug_struct("JpegConfr3").field("xsize", &self.xsize()).finish()
21627 }
21628 }
21629 #[cfg(feature = "defmt")]
21630 impl defmt::Format for JpegConfr3 {
21631 fn format(&self, f: defmt::Formatter) {
21632 #[derive(defmt :: Format)]
21633 struct JpegConfr3 {
21634 xsize: u16,
21635 }
21636 let proxy = JpegConfr3 { xsize: self.xsize() };
21637 defmt::write!(f, "{}", proxy)
21638 }
21639 }
21640 #[doc = "JPEG codec configuration register 4"]
21641 #[repr(transparent)]
21642 #[derive(Copy, Clone, Eq, PartialEq)]
21643 pub struct JpegConfr4(pub u32);
21644 impl JpegConfr4 {
21645 #[doc = "Huffman DC"]
21646 #[inline(always)]
21647 pub const fn hd(&self) -> bool {
21648 let val = (self.0 >> 0usize) & 0x01;
21649 val != 0
21650 }
21651 #[doc = "Huffman DC"]
21652 #[inline(always)]
21653 pub fn set_hd(&mut self, val: bool) {
21654 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
21655 }
21656 #[doc = "Huffman AC"]
21657 #[inline(always)]
21658 pub const fn ha(&self) -> bool {
21659 let val = (self.0 >> 1usize) & 0x01;
21660 val != 0
21661 }
21662 #[doc = "Huffman AC"]
21663 #[inline(always)]
21664 pub fn set_ha(&mut self, val: bool) {
21665 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
21666 }
21667 #[doc = "Quantization Table"]
21668 #[inline(always)]
21669 pub const fn qt(&self) -> u8 {
21670 let val = (self.0 >> 2usize) & 0x03;
21671 val as u8
21672 }
21673 #[doc = "Quantization Table"]
21674 #[inline(always)]
21675 pub fn set_qt(&mut self, val: u8) {
21676 self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
21677 }
21678 #[doc = "Number of Block"]
21679 #[inline(always)]
21680 pub const fn nb(&self) -> u8 {
21681 let val = (self.0 >> 4usize) & 0x0f;
21682 val as u8
21683 }
21684 #[doc = "Number of Block"]
21685 #[inline(always)]
21686 pub fn set_nb(&mut self, val: u8) {
21687 self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
21688 }
21689 #[doc = "Vertical Sampling Factor"]
21690 #[inline(always)]
21691 pub const fn vsf(&self) -> u8 {
21692 let val = (self.0 >> 8usize) & 0x0f;
21693 val as u8
21694 }
21695 #[doc = "Vertical Sampling Factor"]
21696 #[inline(always)]
21697 pub fn set_vsf(&mut self, val: u8) {
21698 self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
21699 }
21700 #[doc = "Horizontal Sampling Factor"]
21701 #[inline(always)]
21702 pub const fn hsf(&self) -> u8 {
21703 let val = (self.0 >> 12usize) & 0x0f;
21704 val as u8
21705 }
21706 #[doc = "Horizontal Sampling Factor"]
21707 #[inline(always)]
21708 pub fn set_hsf(&mut self, val: u8) {
21709 self.0 = (self.0 & !(0x0f << 12usize)) | (((val as u32) & 0x0f) << 12usize);
21710 }
21711 }
21712 impl Default for JpegConfr4 {
21713 #[inline(always)]
21714 fn default() -> JpegConfr4 {
21715 JpegConfr4(0)
21716 }
21717 }
21718 impl core::fmt::Debug for JpegConfr4 {
21719 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21720 f.debug_struct("JpegConfr4")
21721 .field("hd", &self.hd())
21722 .field("ha", &self.ha())
21723 .field("qt", &self.qt())
21724 .field("nb", &self.nb())
21725 .field("vsf", &self.vsf())
21726 .field("hsf", &self.hsf())
21727 .finish()
21728 }
21729 }
21730 #[cfg(feature = "defmt")]
21731 impl defmt::Format for JpegConfr4 {
21732 fn format(&self, f: defmt::Formatter) {
21733 #[derive(defmt :: Format)]
21734 struct JpegConfr4 {
21735 hd: bool,
21736 ha: bool,
21737 qt: u8,
21738 nb: u8,
21739 vsf: u8,
21740 hsf: u8,
21741 }
21742 let proxy = JpegConfr4 {
21743 hd: self.hd(),
21744 ha: self.ha(),
21745 qt: self.qt(),
21746 nb: self.nb(),
21747 vsf: self.vsf(),
21748 hsf: self.hsf(),
21749 };
21750 defmt::write!(f, "{}", proxy)
21751 }
21752 }
21753 #[doc = "JPEG codec configuration register 5"]
21754 #[repr(transparent)]
21755 #[derive(Copy, Clone, Eq, PartialEq)]
21756 pub struct JpegConfr5(pub u32);
21757 impl JpegConfr5 {
21758 #[doc = "Huffman DC"]
21759 #[inline(always)]
21760 pub const fn hd(&self) -> bool {
21761 let val = (self.0 >> 0usize) & 0x01;
21762 val != 0
21763 }
21764 #[doc = "Huffman DC"]
21765 #[inline(always)]
21766 pub fn set_hd(&mut self, val: bool) {
21767 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
21768 }
21769 #[doc = "Huffman AC"]
21770 #[inline(always)]
21771 pub const fn ha(&self) -> bool {
21772 let val = (self.0 >> 1usize) & 0x01;
21773 val != 0
21774 }
21775 #[doc = "Huffman AC"]
21776 #[inline(always)]
21777 pub fn set_ha(&mut self, val: bool) {
21778 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
21779 }
21780 #[doc = "Quantization Table"]
21781 #[inline(always)]
21782 pub const fn qt(&self) -> u8 {
21783 let val = (self.0 >> 2usize) & 0x03;
21784 val as u8
21785 }
21786 #[doc = "Quantization Table"]
21787 #[inline(always)]
21788 pub fn set_qt(&mut self, val: u8) {
21789 self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
21790 }
21791 #[doc = "Number of Block"]
21792 #[inline(always)]
21793 pub const fn nb(&self) -> u8 {
21794 let val = (self.0 >> 4usize) & 0x0f;
21795 val as u8
21796 }
21797 #[doc = "Number of Block"]
21798 #[inline(always)]
21799 pub fn set_nb(&mut self, val: u8) {
21800 self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
21801 }
21802 #[doc = "Vertical Sampling Factor"]
21803 #[inline(always)]
21804 pub const fn vsf(&self) -> u8 {
21805 let val = (self.0 >> 8usize) & 0x0f;
21806 val as u8
21807 }
21808 #[doc = "Vertical Sampling Factor"]
21809 #[inline(always)]
21810 pub fn set_vsf(&mut self, val: u8) {
21811 self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
21812 }
21813 #[doc = "Horizontal Sampling Factor"]
21814 #[inline(always)]
21815 pub const fn hsf(&self) -> u8 {
21816 let val = (self.0 >> 12usize) & 0x0f;
21817 val as u8
21818 }
21819 #[doc = "Horizontal Sampling Factor"]
21820 #[inline(always)]
21821 pub fn set_hsf(&mut self, val: u8) {
21822 self.0 = (self.0 & !(0x0f << 12usize)) | (((val as u32) & 0x0f) << 12usize);
21823 }
21824 }
21825 impl Default for JpegConfr5 {
21826 #[inline(always)]
21827 fn default() -> JpegConfr5 {
21828 JpegConfr5(0)
21829 }
21830 }
21831 impl core::fmt::Debug for JpegConfr5 {
21832 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21833 f.debug_struct("JpegConfr5")
21834 .field("hd", &self.hd())
21835 .field("ha", &self.ha())
21836 .field("qt", &self.qt())
21837 .field("nb", &self.nb())
21838 .field("vsf", &self.vsf())
21839 .field("hsf", &self.hsf())
21840 .finish()
21841 }
21842 }
21843 #[cfg(feature = "defmt")]
21844 impl defmt::Format for JpegConfr5 {
21845 fn format(&self, f: defmt::Formatter) {
21846 #[derive(defmt :: Format)]
21847 struct JpegConfr5 {
21848 hd: bool,
21849 ha: bool,
21850 qt: u8,
21851 nb: u8,
21852 vsf: u8,
21853 hsf: u8,
21854 }
21855 let proxy = JpegConfr5 {
21856 hd: self.hd(),
21857 ha: self.ha(),
21858 qt: self.qt(),
21859 nb: self.nb(),
21860 vsf: self.vsf(),
21861 hsf: self.hsf(),
21862 };
21863 defmt::write!(f, "{}", proxy)
21864 }
21865 }
21866 #[doc = "JPEG codec configuration register 6"]
21867 #[repr(transparent)]
21868 #[derive(Copy, Clone, Eq, PartialEq)]
21869 pub struct JpegConfr6(pub u32);
21870 impl JpegConfr6 {
21871 #[doc = "Huffman DC"]
21872 #[inline(always)]
21873 pub const fn hd(&self) -> bool {
21874 let val = (self.0 >> 0usize) & 0x01;
21875 val != 0
21876 }
21877 #[doc = "Huffman DC"]
21878 #[inline(always)]
21879 pub fn set_hd(&mut self, val: bool) {
21880 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
21881 }
21882 #[doc = "Huffman AC"]
21883 #[inline(always)]
21884 pub const fn ha(&self) -> bool {
21885 let val = (self.0 >> 1usize) & 0x01;
21886 val != 0
21887 }
21888 #[doc = "Huffman AC"]
21889 #[inline(always)]
21890 pub fn set_ha(&mut self, val: bool) {
21891 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
21892 }
21893 #[doc = "Quantization Table"]
21894 #[inline(always)]
21895 pub const fn qt(&self) -> u8 {
21896 let val = (self.0 >> 2usize) & 0x03;
21897 val as u8
21898 }
21899 #[doc = "Quantization Table"]
21900 #[inline(always)]
21901 pub fn set_qt(&mut self, val: u8) {
21902 self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
21903 }
21904 #[doc = "Number of Block"]
21905 #[inline(always)]
21906 pub const fn nb(&self) -> u8 {
21907 let val = (self.0 >> 4usize) & 0x0f;
21908 val as u8
21909 }
21910 #[doc = "Number of Block"]
21911 #[inline(always)]
21912 pub fn set_nb(&mut self, val: u8) {
21913 self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
21914 }
21915 #[doc = "Vertical Sampling Factor"]
21916 #[inline(always)]
21917 pub const fn vsf(&self) -> u8 {
21918 let val = (self.0 >> 8usize) & 0x0f;
21919 val as u8
21920 }
21921 #[doc = "Vertical Sampling Factor"]
21922 #[inline(always)]
21923 pub fn set_vsf(&mut self, val: u8) {
21924 self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
21925 }
21926 #[doc = "Horizontal Sampling Factor"]
21927 #[inline(always)]
21928 pub const fn hsf(&self) -> u8 {
21929 let val = (self.0 >> 12usize) & 0x0f;
21930 val as u8
21931 }
21932 #[doc = "Horizontal Sampling Factor"]
21933 #[inline(always)]
21934 pub fn set_hsf(&mut self, val: u8) {
21935 self.0 = (self.0 & !(0x0f << 12usize)) | (((val as u32) & 0x0f) << 12usize);
21936 }
21937 }
21938 impl Default for JpegConfr6 {
21939 #[inline(always)]
21940 fn default() -> JpegConfr6 {
21941 JpegConfr6(0)
21942 }
21943 }
21944 impl core::fmt::Debug for JpegConfr6 {
21945 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
21946 f.debug_struct("JpegConfr6")
21947 .field("hd", &self.hd())
21948 .field("ha", &self.ha())
21949 .field("qt", &self.qt())
21950 .field("nb", &self.nb())
21951 .field("vsf", &self.vsf())
21952 .field("hsf", &self.hsf())
21953 .finish()
21954 }
21955 }
21956 #[cfg(feature = "defmt")]
21957 impl defmt::Format for JpegConfr6 {
21958 fn format(&self, f: defmt::Formatter) {
21959 #[derive(defmt :: Format)]
21960 struct JpegConfr6 {
21961 hd: bool,
21962 ha: bool,
21963 qt: u8,
21964 nb: u8,
21965 vsf: u8,
21966 hsf: u8,
21967 }
21968 let proxy = JpegConfr6 {
21969 hd: self.hd(),
21970 ha: self.ha(),
21971 qt: self.qt(),
21972 nb: self.nb(),
21973 vsf: self.vsf(),
21974 hsf: self.hsf(),
21975 };
21976 defmt::write!(f, "{}", proxy)
21977 }
21978 }
21979 #[doc = "JPEG codec configuration register 7"]
21980 #[repr(transparent)]
21981 #[derive(Copy, Clone, Eq, PartialEq)]
21982 pub struct JpegConfr7(pub u32);
21983 impl JpegConfr7 {
21984 #[doc = "Huffman DC"]
21985 #[inline(always)]
21986 pub const fn hd(&self) -> bool {
21987 let val = (self.0 >> 0usize) & 0x01;
21988 val != 0
21989 }
21990 #[doc = "Huffman DC"]
21991 #[inline(always)]
21992 pub fn set_hd(&mut self, val: bool) {
21993 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
21994 }
21995 #[doc = "Huffman AC"]
21996 #[inline(always)]
21997 pub const fn ha(&self) -> bool {
21998 let val = (self.0 >> 1usize) & 0x01;
21999 val != 0
22000 }
22001 #[doc = "Huffman AC"]
22002 #[inline(always)]
22003 pub fn set_ha(&mut self, val: bool) {
22004 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
22005 }
22006 #[doc = "Quantization Table"]
22007 #[inline(always)]
22008 pub const fn qt(&self) -> u8 {
22009 let val = (self.0 >> 2usize) & 0x03;
22010 val as u8
22011 }
22012 #[doc = "Quantization Table"]
22013 #[inline(always)]
22014 pub fn set_qt(&mut self, val: u8) {
22015 self.0 = (self.0 & !(0x03 << 2usize)) | (((val as u32) & 0x03) << 2usize);
22016 }
22017 #[doc = "Number of Block"]
22018 #[inline(always)]
22019 pub const fn nb(&self) -> u8 {
22020 let val = (self.0 >> 4usize) & 0x0f;
22021 val as u8
22022 }
22023 #[doc = "Number of Block"]
22024 #[inline(always)]
22025 pub fn set_nb(&mut self, val: u8) {
22026 self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
22027 }
22028 #[doc = "Vertical Sampling Factor"]
22029 #[inline(always)]
22030 pub const fn vsf(&self) -> u8 {
22031 let val = (self.0 >> 8usize) & 0x0f;
22032 val as u8
22033 }
22034 #[doc = "Vertical Sampling Factor"]
22035 #[inline(always)]
22036 pub fn set_vsf(&mut self, val: u8) {
22037 self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
22038 }
22039 #[doc = "Horizontal Sampling Factor"]
22040 #[inline(always)]
22041 pub const fn hsf(&self) -> u8 {
22042 let val = (self.0 >> 12usize) & 0x0f;
22043 val as u8
22044 }
22045 #[doc = "Horizontal Sampling Factor"]
22046 #[inline(always)]
22047 pub fn set_hsf(&mut self, val: u8) {
22048 self.0 = (self.0 & !(0x0f << 12usize)) | (((val as u32) & 0x0f) << 12usize);
22049 }
22050 }
22051 impl Default for JpegConfr7 {
22052 #[inline(always)]
22053 fn default() -> JpegConfr7 {
22054 JpegConfr7(0)
22055 }
22056 }
22057 impl core::fmt::Debug for JpegConfr7 {
22058 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22059 f.debug_struct("JpegConfr7")
22060 .field("hd", &self.hd())
22061 .field("ha", &self.ha())
22062 .field("qt", &self.qt())
22063 .field("nb", &self.nb())
22064 .field("vsf", &self.vsf())
22065 .field("hsf", &self.hsf())
22066 .finish()
22067 }
22068 }
22069 #[cfg(feature = "defmt")]
22070 impl defmt::Format for JpegConfr7 {
22071 fn format(&self, f: defmt::Formatter) {
22072 #[derive(defmt :: Format)]
22073 struct JpegConfr7 {
22074 hd: bool,
22075 ha: bool,
22076 qt: u8,
22077 nb: u8,
22078 vsf: u8,
22079 hsf: u8,
22080 }
22081 let proxy = JpegConfr7 {
22082 hd: self.hd(),
22083 ha: self.ha(),
22084 qt: self.qt(),
22085 nb: self.nb(),
22086 vsf: self.vsf(),
22087 hsf: self.hsf(),
22088 };
22089 defmt::write!(f, "{}", proxy)
22090 }
22091 }
22092 #[doc = "JPEG control register"]
22093 #[repr(transparent)]
22094 #[derive(Copy, Clone, Eq, PartialEq)]
22095 pub struct JpegCr(pub u32);
22096 impl JpegCr {
22097 #[doc = "JPEG Core Enable"]
22098 #[inline(always)]
22099 pub const fn jcen(&self) -> bool {
22100 let val = (self.0 >> 0usize) & 0x01;
22101 val != 0
22102 }
22103 #[doc = "JPEG Core Enable"]
22104 #[inline(always)]
22105 pub fn set_jcen(&mut self, val: bool) {
22106 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
22107 }
22108 #[doc = "Input FIFO Threshold Interrupt Enable"]
22109 #[inline(always)]
22110 pub const fn iftie(&self) -> bool {
22111 let val = (self.0 >> 1usize) & 0x01;
22112 val != 0
22113 }
22114 #[doc = "Input FIFO Threshold Interrupt Enable"]
22115 #[inline(always)]
22116 pub fn set_iftie(&mut self, val: bool) {
22117 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
22118 }
22119 #[doc = "Input FIFO Not Full Interrupt Enable"]
22120 #[inline(always)]
22121 pub const fn ifnfie(&self) -> bool {
22122 let val = (self.0 >> 2usize) & 0x01;
22123 val != 0
22124 }
22125 #[doc = "Input FIFO Not Full Interrupt Enable"]
22126 #[inline(always)]
22127 pub fn set_ifnfie(&mut self, val: bool) {
22128 self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
22129 }
22130 #[doc = "Output FIFO Threshold Interrupt Enable"]
22131 #[inline(always)]
22132 pub const fn oftie(&self) -> bool {
22133 let val = (self.0 >> 3usize) & 0x01;
22134 val != 0
22135 }
22136 #[doc = "Output FIFO Threshold Interrupt Enable"]
22137 #[inline(always)]
22138 pub fn set_oftie(&mut self, val: bool) {
22139 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
22140 }
22141 #[doc = "Output FIFO Not Empty Interrupt Enable"]
22142 #[inline(always)]
22143 pub const fn ofneie(&self) -> bool {
22144 let val = (self.0 >> 4usize) & 0x01;
22145 val != 0
22146 }
22147 #[doc = "Output FIFO Not Empty Interrupt Enable"]
22148 #[inline(always)]
22149 pub fn set_ofneie(&mut self, val: bool) {
22150 self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
22151 }
22152 #[doc = "End of Conversion Interrupt Enable"]
22153 #[inline(always)]
22154 pub const fn eocie(&self) -> bool {
22155 let val = (self.0 >> 5usize) & 0x01;
22156 val != 0
22157 }
22158 #[doc = "End of Conversion Interrupt Enable"]
22159 #[inline(always)]
22160 pub fn set_eocie(&mut self, val: bool) {
22161 self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
22162 }
22163 #[doc = "Header Parsing Done Interrupt Enable"]
22164 #[inline(always)]
22165 pub const fn hpdie(&self) -> bool {
22166 let val = (self.0 >> 6usize) & 0x01;
22167 val != 0
22168 }
22169 #[doc = "Header Parsing Done Interrupt Enable"]
22170 #[inline(always)]
22171 pub fn set_hpdie(&mut self, val: bool) {
22172 self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
22173 }
22174 #[doc = "Input DMA Enable"]
22175 #[inline(always)]
22176 pub const fn idmaen(&self) -> bool {
22177 let val = (self.0 >> 11usize) & 0x01;
22178 val != 0
22179 }
22180 #[doc = "Input DMA Enable"]
22181 #[inline(always)]
22182 pub fn set_idmaen(&mut self, val: bool) {
22183 self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
22184 }
22185 #[doc = "Output DMA Enable"]
22186 #[inline(always)]
22187 pub const fn odmaen(&self) -> bool {
22188 let val = (self.0 >> 12usize) & 0x01;
22189 val != 0
22190 }
22191 #[doc = "Output DMA Enable"]
22192 #[inline(always)]
22193 pub fn set_odmaen(&mut self, val: bool) {
22194 self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
22195 }
22196 #[doc = "Input FIFO Flush"]
22197 #[inline(always)]
22198 pub const fn iff(&self) -> bool {
22199 let val = (self.0 >> 13usize) & 0x01;
22200 val != 0
22201 }
22202 #[doc = "Input FIFO Flush"]
22203 #[inline(always)]
22204 pub fn set_iff(&mut self, val: bool) {
22205 self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
22206 }
22207 #[doc = "Output FIFO Flush"]
22208 #[inline(always)]
22209 pub const fn off(&self) -> bool {
22210 let val = (self.0 >> 14usize) & 0x01;
22211 val != 0
22212 }
22213 #[doc = "Output FIFO Flush"]
22214 #[inline(always)]
22215 pub fn set_off(&mut self, val: bool) {
22216 self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
22217 }
22218 }
22219 impl Default for JpegCr {
22220 #[inline(always)]
22221 fn default() -> JpegCr {
22222 JpegCr(0)
22223 }
22224 }
22225 impl core::fmt::Debug for JpegCr {
22226 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22227 f.debug_struct("JpegCr")
22228 .field("jcen", &self.jcen())
22229 .field("iftie", &self.iftie())
22230 .field("ifnfie", &self.ifnfie())
22231 .field("oftie", &self.oftie())
22232 .field("ofneie", &self.ofneie())
22233 .field("eocie", &self.eocie())
22234 .field("hpdie", &self.hpdie())
22235 .field("idmaen", &self.idmaen())
22236 .field("odmaen", &self.odmaen())
22237 .field("iff", &self.iff())
22238 .field("off", &self.off())
22239 .finish()
22240 }
22241 }
22242 #[cfg(feature = "defmt")]
22243 impl defmt::Format for JpegCr {
22244 fn format(&self, f: defmt::Formatter) {
22245 #[derive(defmt :: Format)]
22246 struct JpegCr {
22247 jcen: bool,
22248 iftie: bool,
22249 ifnfie: bool,
22250 oftie: bool,
22251 ofneie: bool,
22252 eocie: bool,
22253 hpdie: bool,
22254 idmaen: bool,
22255 odmaen: bool,
22256 iff: bool,
22257 off: bool,
22258 }
22259 let proxy = JpegCr {
22260 jcen: self.jcen(),
22261 iftie: self.iftie(),
22262 ifnfie: self.ifnfie(),
22263 oftie: self.oftie(),
22264 ofneie: self.ofneie(),
22265 eocie: self.eocie(),
22266 hpdie: self.hpdie(),
22267 idmaen: self.idmaen(),
22268 odmaen: self.odmaen(),
22269 iff: self.iff(),
22270 off: self.off(),
22271 };
22272 defmt::write!(f, "{}", proxy)
22273 }
22274 }
22275 #[doc = "JPEG data input register"]
22276 #[repr(transparent)]
22277 #[derive(Copy, Clone, Eq, PartialEq)]
22278 pub struct JpegDir(pub u32);
22279 impl JpegDir {
22280 #[doc = "Data Input FIFO"]
22281 #[inline(always)]
22282 pub const fn datain(&self) -> u32 {
22283 let val = (self.0 >> 0usize) & 0xffff_ffff;
22284 val as u32
22285 }
22286 #[doc = "Data Input FIFO"]
22287 #[inline(always)]
22288 pub fn set_datain(&mut self, val: u32) {
22289 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22290 }
22291 }
22292 impl Default for JpegDir {
22293 #[inline(always)]
22294 fn default() -> JpegDir {
22295 JpegDir(0)
22296 }
22297 }
22298 impl core::fmt::Debug for JpegDir {
22299 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22300 f.debug_struct("JpegDir").field("datain", &self.datain()).finish()
22301 }
22302 }
22303 #[cfg(feature = "defmt")]
22304 impl defmt::Format for JpegDir {
22305 fn format(&self, f: defmt::Formatter) {
22306 #[derive(defmt :: Format)]
22307 struct JpegDir {
22308 datain: u32,
22309 }
22310 let proxy = JpegDir { datain: self.datain() };
22311 defmt::write!(f, "{}", proxy)
22312 }
22313 }
22314 #[doc = "JPEG data output register"]
22315 #[repr(transparent)]
22316 #[derive(Copy, Clone, Eq, PartialEq)]
22317 pub struct JpegDor(pub u32);
22318 impl JpegDor {
22319 #[doc = "Data Output FIFO"]
22320 #[inline(always)]
22321 pub const fn dataout(&self) -> u32 {
22322 let val = (self.0 >> 0usize) & 0xffff_ffff;
22323 val as u32
22324 }
22325 #[doc = "Data Output FIFO"]
22326 #[inline(always)]
22327 pub fn set_dataout(&mut self, val: u32) {
22328 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22329 }
22330 }
22331 impl Default for JpegDor {
22332 #[inline(always)]
22333 fn default() -> JpegDor {
22334 JpegDor(0)
22335 }
22336 }
22337 impl core::fmt::Debug for JpegDor {
22338 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22339 f.debug_struct("JpegDor").field("dataout", &self.dataout()).finish()
22340 }
22341 }
22342 #[cfg(feature = "defmt")]
22343 impl defmt::Format for JpegDor {
22344 fn format(&self, f: defmt::Formatter) {
22345 #[derive(defmt :: Format)]
22346 struct JpegDor {
22347 dataout: u32,
22348 }
22349 let proxy = JpegDor {
22350 dataout: self.dataout(),
22351 };
22352 defmt::write!(f, "{}", proxy)
22353 }
22354 }
22355 #[doc = "JPEG status register"]
22356 #[repr(transparent)]
22357 #[derive(Copy, Clone, Eq, PartialEq)]
22358 pub struct JpegSr(pub u32);
22359 impl JpegSr {
22360 #[doc = "Input FIFO Threshold Flag"]
22361 #[inline(always)]
22362 pub const fn iftf(&self) -> bool {
22363 let val = (self.0 >> 1usize) & 0x01;
22364 val != 0
22365 }
22366 #[doc = "Input FIFO Threshold Flag"]
22367 #[inline(always)]
22368 pub fn set_iftf(&mut self, val: bool) {
22369 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
22370 }
22371 #[doc = "Input FIFO Not Full Flag"]
22372 #[inline(always)]
22373 pub const fn ifnff(&self) -> bool {
22374 let val = (self.0 >> 2usize) & 0x01;
22375 val != 0
22376 }
22377 #[doc = "Input FIFO Not Full Flag"]
22378 #[inline(always)]
22379 pub fn set_ifnff(&mut self, val: bool) {
22380 self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
22381 }
22382 #[doc = "Output FIFO Threshold Flag"]
22383 #[inline(always)]
22384 pub const fn oftf(&self) -> bool {
22385 let val = (self.0 >> 3usize) & 0x01;
22386 val != 0
22387 }
22388 #[doc = "Output FIFO Threshold Flag"]
22389 #[inline(always)]
22390 pub fn set_oftf(&mut self, val: bool) {
22391 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
22392 }
22393 #[doc = "Output FIFO Not Empty Flag"]
22394 #[inline(always)]
22395 pub const fn ofnef(&self) -> bool {
22396 let val = (self.0 >> 4usize) & 0x01;
22397 val != 0
22398 }
22399 #[doc = "Output FIFO Not Empty Flag"]
22400 #[inline(always)]
22401 pub fn set_ofnef(&mut self, val: bool) {
22402 self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
22403 }
22404 #[doc = "End of Conversion Flag"]
22405 #[inline(always)]
22406 pub const fn eocf(&self) -> bool {
22407 let val = (self.0 >> 5usize) & 0x01;
22408 val != 0
22409 }
22410 #[doc = "End of Conversion Flag"]
22411 #[inline(always)]
22412 pub fn set_eocf(&mut self, val: bool) {
22413 self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
22414 }
22415 #[doc = "Header Parsing Done Flag"]
22416 #[inline(always)]
22417 pub const fn hpdf(&self) -> bool {
22418 let val = (self.0 >> 6usize) & 0x01;
22419 val != 0
22420 }
22421 #[doc = "Header Parsing Done Flag"]
22422 #[inline(always)]
22423 pub fn set_hpdf(&mut self, val: bool) {
22424 self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
22425 }
22426 #[doc = "Codec Operation Flag"]
22427 #[inline(always)]
22428 pub const fn cof(&self) -> bool {
22429 let val = (self.0 >> 7usize) & 0x01;
22430 val != 0
22431 }
22432 #[doc = "Codec Operation Flag"]
22433 #[inline(always)]
22434 pub fn set_cof(&mut self, val: bool) {
22435 self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
22436 }
22437 }
22438 impl Default for JpegSr {
22439 #[inline(always)]
22440 fn default() -> JpegSr {
22441 JpegSr(0)
22442 }
22443 }
22444 impl core::fmt::Debug for JpegSr {
22445 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22446 f.debug_struct("JpegSr")
22447 .field("iftf", &self.iftf())
22448 .field("ifnff", &self.ifnff())
22449 .field("oftf", &self.oftf())
22450 .field("ofnef", &self.ofnef())
22451 .field("eocf", &self.eocf())
22452 .field("hpdf", &self.hpdf())
22453 .field("cof", &self.cof())
22454 .finish()
22455 }
22456 }
22457 #[cfg(feature = "defmt")]
22458 impl defmt::Format for JpegSr {
22459 fn format(&self, f: defmt::Formatter) {
22460 #[derive(defmt :: Format)]
22461 struct JpegSr {
22462 iftf: bool,
22463 ifnff: bool,
22464 oftf: bool,
22465 ofnef: bool,
22466 eocf: bool,
22467 hpdf: bool,
22468 cof: bool,
22469 }
22470 let proxy = JpegSr {
22471 iftf: self.iftf(),
22472 ifnff: self.ifnff(),
22473 oftf: self.oftf(),
22474 ofnef: self.ofnef(),
22475 eocf: self.eocf(),
22476 hpdf: self.hpdf(),
22477 cof: self.cof(),
22478 };
22479 defmt::write!(f, "{}", proxy)
22480 }
22481 }
22482 #[doc = "JPEG quantization tables"]
22483 #[repr(transparent)]
22484 #[derive(Copy, Clone, Eq, PartialEq)]
22485 pub struct Qmem00(pub u32);
22486 impl Qmem00 {
22487 #[doc = "QMem RAM"]
22488 #[inline(always)]
22489 pub const fn qmem_ram(&self) -> u32 {
22490 let val = (self.0 >> 0usize) & 0xffff_ffff;
22491 val as u32
22492 }
22493 #[doc = "QMem RAM"]
22494 #[inline(always)]
22495 pub fn set_qmem_ram(&mut self, val: u32) {
22496 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22497 }
22498 }
22499 impl Default for Qmem00 {
22500 #[inline(always)]
22501 fn default() -> Qmem00 {
22502 Qmem00(0)
22503 }
22504 }
22505 impl core::fmt::Debug for Qmem00 {
22506 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22507 f.debug_struct("Qmem00").field("qmem_ram", &self.qmem_ram()).finish()
22508 }
22509 }
22510 #[cfg(feature = "defmt")]
22511 impl defmt::Format for Qmem00 {
22512 fn format(&self, f: defmt::Formatter) {
22513 #[derive(defmt :: Format)]
22514 struct Qmem00 {
22515 qmem_ram: u32,
22516 }
22517 let proxy = Qmem00 {
22518 qmem_ram: self.qmem_ram(),
22519 };
22520 defmt::write!(f, "{}", proxy)
22521 }
22522 }
22523 #[doc = "JPEG quantization tables"]
22524 #[repr(transparent)]
22525 #[derive(Copy, Clone, Eq, PartialEq)]
22526 pub struct Qmem01(pub u32);
22527 impl Qmem01 {
22528 #[doc = "QMem RAM"]
22529 #[inline(always)]
22530 pub const fn qmem_ram(&self) -> u32 {
22531 let val = (self.0 >> 0usize) & 0xffff_ffff;
22532 val as u32
22533 }
22534 #[doc = "QMem RAM"]
22535 #[inline(always)]
22536 pub fn set_qmem_ram(&mut self, val: u32) {
22537 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22538 }
22539 }
22540 impl Default for Qmem01 {
22541 #[inline(always)]
22542 fn default() -> Qmem01 {
22543 Qmem01(0)
22544 }
22545 }
22546 impl core::fmt::Debug for Qmem01 {
22547 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22548 f.debug_struct("Qmem01").field("qmem_ram", &self.qmem_ram()).finish()
22549 }
22550 }
22551 #[cfg(feature = "defmt")]
22552 impl defmt::Format for Qmem01 {
22553 fn format(&self, f: defmt::Formatter) {
22554 #[derive(defmt :: Format)]
22555 struct Qmem01 {
22556 qmem_ram: u32,
22557 }
22558 let proxy = Qmem01 {
22559 qmem_ram: self.qmem_ram(),
22560 };
22561 defmt::write!(f, "{}", proxy)
22562 }
22563 }
22564 #[doc = "JPEG quantization tables"]
22565 #[repr(transparent)]
22566 #[derive(Copy, Clone, Eq, PartialEq)]
22567 pub struct Qmem010(pub u32);
22568 impl Qmem010 {
22569 #[doc = "QMem RAM"]
22570 #[inline(always)]
22571 pub const fn qmem_ram(&self) -> u32 {
22572 let val = (self.0 >> 0usize) & 0xffff_ffff;
22573 val as u32
22574 }
22575 #[doc = "QMem RAM"]
22576 #[inline(always)]
22577 pub fn set_qmem_ram(&mut self, val: u32) {
22578 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22579 }
22580 }
22581 impl Default for Qmem010 {
22582 #[inline(always)]
22583 fn default() -> Qmem010 {
22584 Qmem010(0)
22585 }
22586 }
22587 impl core::fmt::Debug for Qmem010 {
22588 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22589 f.debug_struct("Qmem010").field("qmem_ram", &self.qmem_ram()).finish()
22590 }
22591 }
22592 #[cfg(feature = "defmt")]
22593 impl defmt::Format for Qmem010 {
22594 fn format(&self, f: defmt::Formatter) {
22595 #[derive(defmt :: Format)]
22596 struct Qmem010 {
22597 qmem_ram: u32,
22598 }
22599 let proxy = Qmem010 {
22600 qmem_ram: self.qmem_ram(),
22601 };
22602 defmt::write!(f, "{}", proxy)
22603 }
22604 }
22605 #[doc = "JPEG quantization tables"]
22606 #[repr(transparent)]
22607 #[derive(Copy, Clone, Eq, PartialEq)]
22608 pub struct Qmem011(pub u32);
22609 impl Qmem011 {
22610 #[doc = "QMem RAM"]
22611 #[inline(always)]
22612 pub const fn qmem_ram(&self) -> u32 {
22613 let val = (self.0 >> 0usize) & 0xffff_ffff;
22614 val as u32
22615 }
22616 #[doc = "QMem RAM"]
22617 #[inline(always)]
22618 pub fn set_qmem_ram(&mut self, val: u32) {
22619 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22620 }
22621 }
22622 impl Default for Qmem011 {
22623 #[inline(always)]
22624 fn default() -> Qmem011 {
22625 Qmem011(0)
22626 }
22627 }
22628 impl core::fmt::Debug for Qmem011 {
22629 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22630 f.debug_struct("Qmem011").field("qmem_ram", &self.qmem_ram()).finish()
22631 }
22632 }
22633 #[cfg(feature = "defmt")]
22634 impl defmt::Format for Qmem011 {
22635 fn format(&self, f: defmt::Formatter) {
22636 #[derive(defmt :: Format)]
22637 struct Qmem011 {
22638 qmem_ram: u32,
22639 }
22640 let proxy = Qmem011 {
22641 qmem_ram: self.qmem_ram(),
22642 };
22643 defmt::write!(f, "{}", proxy)
22644 }
22645 }
22646 #[doc = "JPEG quantization tables"]
22647 #[repr(transparent)]
22648 #[derive(Copy, Clone, Eq, PartialEq)]
22649 pub struct Qmem012(pub u32);
22650 impl Qmem012 {
22651 #[doc = "QMem RAM"]
22652 #[inline(always)]
22653 pub const fn qmem_ram(&self) -> u32 {
22654 let val = (self.0 >> 0usize) & 0xffff_ffff;
22655 val as u32
22656 }
22657 #[doc = "QMem RAM"]
22658 #[inline(always)]
22659 pub fn set_qmem_ram(&mut self, val: u32) {
22660 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22661 }
22662 }
22663 impl Default for Qmem012 {
22664 #[inline(always)]
22665 fn default() -> Qmem012 {
22666 Qmem012(0)
22667 }
22668 }
22669 impl core::fmt::Debug for Qmem012 {
22670 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22671 f.debug_struct("Qmem012").field("qmem_ram", &self.qmem_ram()).finish()
22672 }
22673 }
22674 #[cfg(feature = "defmt")]
22675 impl defmt::Format for Qmem012 {
22676 fn format(&self, f: defmt::Formatter) {
22677 #[derive(defmt :: Format)]
22678 struct Qmem012 {
22679 qmem_ram: u32,
22680 }
22681 let proxy = Qmem012 {
22682 qmem_ram: self.qmem_ram(),
22683 };
22684 defmt::write!(f, "{}", proxy)
22685 }
22686 }
22687 #[doc = "JPEG quantization tables"]
22688 #[repr(transparent)]
22689 #[derive(Copy, Clone, Eq, PartialEq)]
22690 pub struct Qmem013(pub u32);
22691 impl Qmem013 {
22692 #[doc = "QMem RAM"]
22693 #[inline(always)]
22694 pub const fn qmem_ram(&self) -> u32 {
22695 let val = (self.0 >> 0usize) & 0xffff_ffff;
22696 val as u32
22697 }
22698 #[doc = "QMem RAM"]
22699 #[inline(always)]
22700 pub fn set_qmem_ram(&mut self, val: u32) {
22701 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22702 }
22703 }
22704 impl Default for Qmem013 {
22705 #[inline(always)]
22706 fn default() -> Qmem013 {
22707 Qmem013(0)
22708 }
22709 }
22710 impl core::fmt::Debug for Qmem013 {
22711 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22712 f.debug_struct("Qmem013").field("qmem_ram", &self.qmem_ram()).finish()
22713 }
22714 }
22715 #[cfg(feature = "defmt")]
22716 impl defmt::Format for Qmem013 {
22717 fn format(&self, f: defmt::Formatter) {
22718 #[derive(defmt :: Format)]
22719 struct Qmem013 {
22720 qmem_ram: u32,
22721 }
22722 let proxy = Qmem013 {
22723 qmem_ram: self.qmem_ram(),
22724 };
22725 defmt::write!(f, "{}", proxy)
22726 }
22727 }
22728 #[doc = "JPEG quantization tables"]
22729 #[repr(transparent)]
22730 #[derive(Copy, Clone, Eq, PartialEq)]
22731 pub struct Qmem014(pub u32);
22732 impl Qmem014 {
22733 #[doc = "QMem RAM"]
22734 #[inline(always)]
22735 pub const fn qmem_ram(&self) -> u32 {
22736 let val = (self.0 >> 0usize) & 0xffff_ffff;
22737 val as u32
22738 }
22739 #[doc = "QMem RAM"]
22740 #[inline(always)]
22741 pub fn set_qmem_ram(&mut self, val: u32) {
22742 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22743 }
22744 }
22745 impl Default for Qmem014 {
22746 #[inline(always)]
22747 fn default() -> Qmem014 {
22748 Qmem014(0)
22749 }
22750 }
22751 impl core::fmt::Debug for Qmem014 {
22752 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22753 f.debug_struct("Qmem014").field("qmem_ram", &self.qmem_ram()).finish()
22754 }
22755 }
22756 #[cfg(feature = "defmt")]
22757 impl defmt::Format for Qmem014 {
22758 fn format(&self, f: defmt::Formatter) {
22759 #[derive(defmt :: Format)]
22760 struct Qmem014 {
22761 qmem_ram: u32,
22762 }
22763 let proxy = Qmem014 {
22764 qmem_ram: self.qmem_ram(),
22765 };
22766 defmt::write!(f, "{}", proxy)
22767 }
22768 }
22769 #[doc = "JPEG quantization tables"]
22770 #[repr(transparent)]
22771 #[derive(Copy, Clone, Eq, PartialEq)]
22772 pub struct Qmem015(pub u32);
22773 impl Qmem015 {
22774 #[doc = "QMem RAM"]
22775 #[inline(always)]
22776 pub const fn qmem_ram(&self) -> u32 {
22777 let val = (self.0 >> 0usize) & 0xffff_ffff;
22778 val as u32
22779 }
22780 #[doc = "QMem RAM"]
22781 #[inline(always)]
22782 pub fn set_qmem_ram(&mut self, val: u32) {
22783 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22784 }
22785 }
22786 impl Default for Qmem015 {
22787 #[inline(always)]
22788 fn default() -> Qmem015 {
22789 Qmem015(0)
22790 }
22791 }
22792 impl core::fmt::Debug for Qmem015 {
22793 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22794 f.debug_struct("Qmem015").field("qmem_ram", &self.qmem_ram()).finish()
22795 }
22796 }
22797 #[cfg(feature = "defmt")]
22798 impl defmt::Format for Qmem015 {
22799 fn format(&self, f: defmt::Formatter) {
22800 #[derive(defmt :: Format)]
22801 struct Qmem015 {
22802 qmem_ram: u32,
22803 }
22804 let proxy = Qmem015 {
22805 qmem_ram: self.qmem_ram(),
22806 };
22807 defmt::write!(f, "{}", proxy)
22808 }
22809 }
22810 #[doc = "JPEG quantization tables"]
22811 #[repr(transparent)]
22812 #[derive(Copy, Clone, Eq, PartialEq)]
22813 pub struct Qmem02(pub u32);
22814 impl Qmem02 {
22815 #[doc = "QMem RAM"]
22816 #[inline(always)]
22817 pub const fn qmem_ram(&self) -> u32 {
22818 let val = (self.0 >> 0usize) & 0xffff_ffff;
22819 val as u32
22820 }
22821 #[doc = "QMem RAM"]
22822 #[inline(always)]
22823 pub fn set_qmem_ram(&mut self, val: u32) {
22824 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22825 }
22826 }
22827 impl Default for Qmem02 {
22828 #[inline(always)]
22829 fn default() -> Qmem02 {
22830 Qmem02(0)
22831 }
22832 }
22833 impl core::fmt::Debug for Qmem02 {
22834 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22835 f.debug_struct("Qmem02").field("qmem_ram", &self.qmem_ram()).finish()
22836 }
22837 }
22838 #[cfg(feature = "defmt")]
22839 impl defmt::Format for Qmem02 {
22840 fn format(&self, f: defmt::Formatter) {
22841 #[derive(defmt :: Format)]
22842 struct Qmem02 {
22843 qmem_ram: u32,
22844 }
22845 let proxy = Qmem02 {
22846 qmem_ram: self.qmem_ram(),
22847 };
22848 defmt::write!(f, "{}", proxy)
22849 }
22850 }
22851 #[doc = "JPEG quantization tables"]
22852 #[repr(transparent)]
22853 #[derive(Copy, Clone, Eq, PartialEq)]
22854 pub struct Qmem03(pub u32);
22855 impl Qmem03 {
22856 #[doc = "QMem RAM"]
22857 #[inline(always)]
22858 pub const fn qmem_ram(&self) -> u32 {
22859 let val = (self.0 >> 0usize) & 0xffff_ffff;
22860 val as u32
22861 }
22862 #[doc = "QMem RAM"]
22863 #[inline(always)]
22864 pub fn set_qmem_ram(&mut self, val: u32) {
22865 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22866 }
22867 }
22868 impl Default for Qmem03 {
22869 #[inline(always)]
22870 fn default() -> Qmem03 {
22871 Qmem03(0)
22872 }
22873 }
22874 impl core::fmt::Debug for Qmem03 {
22875 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22876 f.debug_struct("Qmem03").field("qmem_ram", &self.qmem_ram()).finish()
22877 }
22878 }
22879 #[cfg(feature = "defmt")]
22880 impl defmt::Format for Qmem03 {
22881 fn format(&self, f: defmt::Formatter) {
22882 #[derive(defmt :: Format)]
22883 struct Qmem03 {
22884 qmem_ram: u32,
22885 }
22886 let proxy = Qmem03 {
22887 qmem_ram: self.qmem_ram(),
22888 };
22889 defmt::write!(f, "{}", proxy)
22890 }
22891 }
22892 #[doc = "JPEG quantization tables"]
22893 #[repr(transparent)]
22894 #[derive(Copy, Clone, Eq, PartialEq)]
22895 pub struct Qmem04(pub u32);
22896 impl Qmem04 {
22897 #[doc = "QMem RAM"]
22898 #[inline(always)]
22899 pub const fn qmem_ram(&self) -> u32 {
22900 let val = (self.0 >> 0usize) & 0xffff_ffff;
22901 val as u32
22902 }
22903 #[doc = "QMem RAM"]
22904 #[inline(always)]
22905 pub fn set_qmem_ram(&mut self, val: u32) {
22906 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22907 }
22908 }
22909 impl Default for Qmem04 {
22910 #[inline(always)]
22911 fn default() -> Qmem04 {
22912 Qmem04(0)
22913 }
22914 }
22915 impl core::fmt::Debug for Qmem04 {
22916 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22917 f.debug_struct("Qmem04").field("qmem_ram", &self.qmem_ram()).finish()
22918 }
22919 }
22920 #[cfg(feature = "defmt")]
22921 impl defmt::Format for Qmem04 {
22922 fn format(&self, f: defmt::Formatter) {
22923 #[derive(defmt :: Format)]
22924 struct Qmem04 {
22925 qmem_ram: u32,
22926 }
22927 let proxy = Qmem04 {
22928 qmem_ram: self.qmem_ram(),
22929 };
22930 defmt::write!(f, "{}", proxy)
22931 }
22932 }
22933 #[doc = "JPEG quantization tables"]
22934 #[repr(transparent)]
22935 #[derive(Copy, Clone, Eq, PartialEq)]
22936 pub struct Qmem05(pub u32);
22937 impl Qmem05 {
22938 #[doc = "QMem RAM"]
22939 #[inline(always)]
22940 pub const fn qmem_ram(&self) -> u32 {
22941 let val = (self.0 >> 0usize) & 0xffff_ffff;
22942 val as u32
22943 }
22944 #[doc = "QMem RAM"]
22945 #[inline(always)]
22946 pub fn set_qmem_ram(&mut self, val: u32) {
22947 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22948 }
22949 }
22950 impl Default for Qmem05 {
22951 #[inline(always)]
22952 fn default() -> Qmem05 {
22953 Qmem05(0)
22954 }
22955 }
22956 impl core::fmt::Debug for Qmem05 {
22957 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22958 f.debug_struct("Qmem05").field("qmem_ram", &self.qmem_ram()).finish()
22959 }
22960 }
22961 #[cfg(feature = "defmt")]
22962 impl defmt::Format for Qmem05 {
22963 fn format(&self, f: defmt::Formatter) {
22964 #[derive(defmt :: Format)]
22965 struct Qmem05 {
22966 qmem_ram: u32,
22967 }
22968 let proxy = Qmem05 {
22969 qmem_ram: self.qmem_ram(),
22970 };
22971 defmt::write!(f, "{}", proxy)
22972 }
22973 }
22974 #[doc = "JPEG quantization tables"]
22975 #[repr(transparent)]
22976 #[derive(Copy, Clone, Eq, PartialEq)]
22977 pub struct Qmem06(pub u32);
22978 impl Qmem06 {
22979 #[doc = "QMem RAM"]
22980 #[inline(always)]
22981 pub const fn qmem_ram(&self) -> u32 {
22982 let val = (self.0 >> 0usize) & 0xffff_ffff;
22983 val as u32
22984 }
22985 #[doc = "QMem RAM"]
22986 #[inline(always)]
22987 pub fn set_qmem_ram(&mut self, val: u32) {
22988 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
22989 }
22990 }
22991 impl Default for Qmem06 {
22992 #[inline(always)]
22993 fn default() -> Qmem06 {
22994 Qmem06(0)
22995 }
22996 }
22997 impl core::fmt::Debug for Qmem06 {
22998 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
22999 f.debug_struct("Qmem06").field("qmem_ram", &self.qmem_ram()).finish()
23000 }
23001 }
23002 #[cfg(feature = "defmt")]
23003 impl defmt::Format for Qmem06 {
23004 fn format(&self, f: defmt::Formatter) {
23005 #[derive(defmt :: Format)]
23006 struct Qmem06 {
23007 qmem_ram: u32,
23008 }
23009 let proxy = Qmem06 {
23010 qmem_ram: self.qmem_ram(),
23011 };
23012 defmt::write!(f, "{}", proxy)
23013 }
23014 }
23015 #[doc = "JPEG quantization tables"]
23016 #[repr(transparent)]
23017 #[derive(Copy, Clone, Eq, PartialEq)]
23018 pub struct Qmem07(pub u32);
23019 impl Qmem07 {
23020 #[doc = "QMem RAM"]
23021 #[inline(always)]
23022 pub const fn qmem_ram(&self) -> u32 {
23023 let val = (self.0 >> 0usize) & 0xffff_ffff;
23024 val as u32
23025 }
23026 #[doc = "QMem RAM"]
23027 #[inline(always)]
23028 pub fn set_qmem_ram(&mut self, val: u32) {
23029 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23030 }
23031 }
23032 impl Default for Qmem07 {
23033 #[inline(always)]
23034 fn default() -> Qmem07 {
23035 Qmem07(0)
23036 }
23037 }
23038 impl core::fmt::Debug for Qmem07 {
23039 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23040 f.debug_struct("Qmem07").field("qmem_ram", &self.qmem_ram()).finish()
23041 }
23042 }
23043 #[cfg(feature = "defmt")]
23044 impl defmt::Format for Qmem07 {
23045 fn format(&self, f: defmt::Formatter) {
23046 #[derive(defmt :: Format)]
23047 struct Qmem07 {
23048 qmem_ram: u32,
23049 }
23050 let proxy = Qmem07 {
23051 qmem_ram: self.qmem_ram(),
23052 };
23053 defmt::write!(f, "{}", proxy)
23054 }
23055 }
23056 #[doc = "JPEG quantization tables"]
23057 #[repr(transparent)]
23058 #[derive(Copy, Clone, Eq, PartialEq)]
23059 pub struct Qmem08(pub u32);
23060 impl Qmem08 {
23061 #[doc = "QMem RAM"]
23062 #[inline(always)]
23063 pub const fn qmem_ram(&self) -> u32 {
23064 let val = (self.0 >> 0usize) & 0xffff_ffff;
23065 val as u32
23066 }
23067 #[doc = "QMem RAM"]
23068 #[inline(always)]
23069 pub fn set_qmem_ram(&mut self, val: u32) {
23070 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23071 }
23072 }
23073 impl Default for Qmem08 {
23074 #[inline(always)]
23075 fn default() -> Qmem08 {
23076 Qmem08(0)
23077 }
23078 }
23079 impl core::fmt::Debug for Qmem08 {
23080 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23081 f.debug_struct("Qmem08").field("qmem_ram", &self.qmem_ram()).finish()
23082 }
23083 }
23084 #[cfg(feature = "defmt")]
23085 impl defmt::Format for Qmem08 {
23086 fn format(&self, f: defmt::Formatter) {
23087 #[derive(defmt :: Format)]
23088 struct Qmem08 {
23089 qmem_ram: u32,
23090 }
23091 let proxy = Qmem08 {
23092 qmem_ram: self.qmem_ram(),
23093 };
23094 defmt::write!(f, "{}", proxy)
23095 }
23096 }
23097 #[doc = "JPEG quantization tables"]
23098 #[repr(transparent)]
23099 #[derive(Copy, Clone, Eq, PartialEq)]
23100 pub struct Qmem09(pub u32);
23101 impl Qmem09 {
23102 #[doc = "QMem RAM"]
23103 #[inline(always)]
23104 pub const fn qmem_ram(&self) -> u32 {
23105 let val = (self.0 >> 0usize) & 0xffff_ffff;
23106 val as u32
23107 }
23108 #[doc = "QMem RAM"]
23109 #[inline(always)]
23110 pub fn set_qmem_ram(&mut self, val: u32) {
23111 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23112 }
23113 }
23114 impl Default for Qmem09 {
23115 #[inline(always)]
23116 fn default() -> Qmem09 {
23117 Qmem09(0)
23118 }
23119 }
23120 impl core::fmt::Debug for Qmem09 {
23121 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23122 f.debug_struct("Qmem09").field("qmem_ram", &self.qmem_ram()).finish()
23123 }
23124 }
23125 #[cfg(feature = "defmt")]
23126 impl defmt::Format for Qmem09 {
23127 fn format(&self, f: defmt::Formatter) {
23128 #[derive(defmt :: Format)]
23129 struct Qmem09 {
23130 qmem_ram: u32,
23131 }
23132 let proxy = Qmem09 {
23133 qmem_ram: self.qmem_ram(),
23134 };
23135 defmt::write!(f, "{}", proxy)
23136 }
23137 }
23138 #[doc = "JPEG quantization tables"]
23139 #[repr(transparent)]
23140 #[derive(Copy, Clone, Eq, PartialEq)]
23141 pub struct Qmem10(pub u32);
23142 impl Qmem10 {
23143 #[doc = "QMem RAM"]
23144 #[inline(always)]
23145 pub const fn qmem_ram(&self) -> u32 {
23146 let val = (self.0 >> 0usize) & 0xffff_ffff;
23147 val as u32
23148 }
23149 #[doc = "QMem RAM"]
23150 #[inline(always)]
23151 pub fn set_qmem_ram(&mut self, val: u32) {
23152 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23153 }
23154 }
23155 impl Default for Qmem10 {
23156 #[inline(always)]
23157 fn default() -> Qmem10 {
23158 Qmem10(0)
23159 }
23160 }
23161 impl core::fmt::Debug for Qmem10 {
23162 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23163 f.debug_struct("Qmem10").field("qmem_ram", &self.qmem_ram()).finish()
23164 }
23165 }
23166 #[cfg(feature = "defmt")]
23167 impl defmt::Format for Qmem10 {
23168 fn format(&self, f: defmt::Formatter) {
23169 #[derive(defmt :: Format)]
23170 struct Qmem10 {
23171 qmem_ram: u32,
23172 }
23173 let proxy = Qmem10 {
23174 qmem_ram: self.qmem_ram(),
23175 };
23176 defmt::write!(f, "{}", proxy)
23177 }
23178 }
23179 #[doc = "JPEG quantization tables"]
23180 #[repr(transparent)]
23181 #[derive(Copy, Clone, Eq, PartialEq)]
23182 pub struct Qmem11(pub u32);
23183 impl Qmem11 {
23184 #[doc = "QMem RAM"]
23185 #[inline(always)]
23186 pub const fn qmem_ram(&self) -> u32 {
23187 let val = (self.0 >> 0usize) & 0xffff_ffff;
23188 val as u32
23189 }
23190 #[doc = "QMem RAM"]
23191 #[inline(always)]
23192 pub fn set_qmem_ram(&mut self, val: u32) {
23193 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23194 }
23195 }
23196 impl Default for Qmem11 {
23197 #[inline(always)]
23198 fn default() -> Qmem11 {
23199 Qmem11(0)
23200 }
23201 }
23202 impl core::fmt::Debug for Qmem11 {
23203 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23204 f.debug_struct("Qmem11").field("qmem_ram", &self.qmem_ram()).finish()
23205 }
23206 }
23207 #[cfg(feature = "defmt")]
23208 impl defmt::Format for Qmem11 {
23209 fn format(&self, f: defmt::Formatter) {
23210 #[derive(defmt :: Format)]
23211 struct Qmem11 {
23212 qmem_ram: u32,
23213 }
23214 let proxy = Qmem11 {
23215 qmem_ram: self.qmem_ram(),
23216 };
23217 defmt::write!(f, "{}", proxy)
23218 }
23219 }
23220 #[doc = "JPEG quantization tables"]
23221 #[repr(transparent)]
23222 #[derive(Copy, Clone, Eq, PartialEq)]
23223 pub struct Qmem110(pub u32);
23224 impl Qmem110 {
23225 #[doc = "QMem RAM"]
23226 #[inline(always)]
23227 pub const fn qmem_ram(&self) -> u32 {
23228 let val = (self.0 >> 0usize) & 0xffff_ffff;
23229 val as u32
23230 }
23231 #[doc = "QMem RAM"]
23232 #[inline(always)]
23233 pub fn set_qmem_ram(&mut self, val: u32) {
23234 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23235 }
23236 }
23237 impl Default for Qmem110 {
23238 #[inline(always)]
23239 fn default() -> Qmem110 {
23240 Qmem110(0)
23241 }
23242 }
23243 impl core::fmt::Debug for Qmem110 {
23244 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23245 f.debug_struct("Qmem110").field("qmem_ram", &self.qmem_ram()).finish()
23246 }
23247 }
23248 #[cfg(feature = "defmt")]
23249 impl defmt::Format for Qmem110 {
23250 fn format(&self, f: defmt::Formatter) {
23251 #[derive(defmt :: Format)]
23252 struct Qmem110 {
23253 qmem_ram: u32,
23254 }
23255 let proxy = Qmem110 {
23256 qmem_ram: self.qmem_ram(),
23257 };
23258 defmt::write!(f, "{}", proxy)
23259 }
23260 }
23261 #[doc = "JPEG quantization tables"]
23262 #[repr(transparent)]
23263 #[derive(Copy, Clone, Eq, PartialEq)]
23264 pub struct Qmem111(pub u32);
23265 impl Qmem111 {
23266 #[doc = "QMem RAM"]
23267 #[inline(always)]
23268 pub const fn qmem_ram(&self) -> u32 {
23269 let val = (self.0 >> 0usize) & 0xffff_ffff;
23270 val as u32
23271 }
23272 #[doc = "QMem RAM"]
23273 #[inline(always)]
23274 pub fn set_qmem_ram(&mut self, val: u32) {
23275 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23276 }
23277 }
23278 impl Default for Qmem111 {
23279 #[inline(always)]
23280 fn default() -> Qmem111 {
23281 Qmem111(0)
23282 }
23283 }
23284 impl core::fmt::Debug for Qmem111 {
23285 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23286 f.debug_struct("Qmem111").field("qmem_ram", &self.qmem_ram()).finish()
23287 }
23288 }
23289 #[cfg(feature = "defmt")]
23290 impl defmt::Format for Qmem111 {
23291 fn format(&self, f: defmt::Formatter) {
23292 #[derive(defmt :: Format)]
23293 struct Qmem111 {
23294 qmem_ram: u32,
23295 }
23296 let proxy = Qmem111 {
23297 qmem_ram: self.qmem_ram(),
23298 };
23299 defmt::write!(f, "{}", proxy)
23300 }
23301 }
23302 #[doc = "JPEG quantization tables"]
23303 #[repr(transparent)]
23304 #[derive(Copy, Clone, Eq, PartialEq)]
23305 pub struct Qmem112(pub u32);
23306 impl Qmem112 {
23307 #[doc = "QMem RAM"]
23308 #[inline(always)]
23309 pub const fn qmem_ram(&self) -> u32 {
23310 let val = (self.0 >> 0usize) & 0xffff_ffff;
23311 val as u32
23312 }
23313 #[doc = "QMem RAM"]
23314 #[inline(always)]
23315 pub fn set_qmem_ram(&mut self, val: u32) {
23316 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23317 }
23318 }
23319 impl Default for Qmem112 {
23320 #[inline(always)]
23321 fn default() -> Qmem112 {
23322 Qmem112(0)
23323 }
23324 }
23325 impl core::fmt::Debug for Qmem112 {
23326 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23327 f.debug_struct("Qmem112").field("qmem_ram", &self.qmem_ram()).finish()
23328 }
23329 }
23330 #[cfg(feature = "defmt")]
23331 impl defmt::Format for Qmem112 {
23332 fn format(&self, f: defmt::Formatter) {
23333 #[derive(defmt :: Format)]
23334 struct Qmem112 {
23335 qmem_ram: u32,
23336 }
23337 let proxy = Qmem112 {
23338 qmem_ram: self.qmem_ram(),
23339 };
23340 defmt::write!(f, "{}", proxy)
23341 }
23342 }
23343 #[doc = "JPEG quantization tables"]
23344 #[repr(transparent)]
23345 #[derive(Copy, Clone, Eq, PartialEq)]
23346 pub struct Qmem113(pub u32);
23347 impl Qmem113 {
23348 #[doc = "QMem RAM"]
23349 #[inline(always)]
23350 pub const fn qmem_ram(&self) -> u32 {
23351 let val = (self.0 >> 0usize) & 0xffff_ffff;
23352 val as u32
23353 }
23354 #[doc = "QMem RAM"]
23355 #[inline(always)]
23356 pub fn set_qmem_ram(&mut self, val: u32) {
23357 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23358 }
23359 }
23360 impl Default for Qmem113 {
23361 #[inline(always)]
23362 fn default() -> Qmem113 {
23363 Qmem113(0)
23364 }
23365 }
23366 impl core::fmt::Debug for Qmem113 {
23367 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23368 f.debug_struct("Qmem113").field("qmem_ram", &self.qmem_ram()).finish()
23369 }
23370 }
23371 #[cfg(feature = "defmt")]
23372 impl defmt::Format for Qmem113 {
23373 fn format(&self, f: defmt::Formatter) {
23374 #[derive(defmt :: Format)]
23375 struct Qmem113 {
23376 qmem_ram: u32,
23377 }
23378 let proxy = Qmem113 {
23379 qmem_ram: self.qmem_ram(),
23380 };
23381 defmt::write!(f, "{}", proxy)
23382 }
23383 }
23384 #[doc = "JPEG quantization tables"]
23385 #[repr(transparent)]
23386 #[derive(Copy, Clone, Eq, PartialEq)]
23387 pub struct Qmem114(pub u32);
23388 impl Qmem114 {
23389 #[doc = "QMem RAM"]
23390 #[inline(always)]
23391 pub const fn qmem_ram(&self) -> u32 {
23392 let val = (self.0 >> 0usize) & 0xffff_ffff;
23393 val as u32
23394 }
23395 #[doc = "QMem RAM"]
23396 #[inline(always)]
23397 pub fn set_qmem_ram(&mut self, val: u32) {
23398 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23399 }
23400 }
23401 impl Default for Qmem114 {
23402 #[inline(always)]
23403 fn default() -> Qmem114 {
23404 Qmem114(0)
23405 }
23406 }
23407 impl core::fmt::Debug for Qmem114 {
23408 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23409 f.debug_struct("Qmem114").field("qmem_ram", &self.qmem_ram()).finish()
23410 }
23411 }
23412 #[cfg(feature = "defmt")]
23413 impl defmt::Format for Qmem114 {
23414 fn format(&self, f: defmt::Formatter) {
23415 #[derive(defmt :: Format)]
23416 struct Qmem114 {
23417 qmem_ram: u32,
23418 }
23419 let proxy = Qmem114 {
23420 qmem_ram: self.qmem_ram(),
23421 };
23422 defmt::write!(f, "{}", proxy)
23423 }
23424 }
23425 #[doc = "JPEG quantization tables"]
23426 #[repr(transparent)]
23427 #[derive(Copy, Clone, Eq, PartialEq)]
23428 pub struct Qmem115(pub u32);
23429 impl Qmem115 {
23430 #[doc = "QMem RAM"]
23431 #[inline(always)]
23432 pub const fn qmem_ram(&self) -> u32 {
23433 let val = (self.0 >> 0usize) & 0xffff_ffff;
23434 val as u32
23435 }
23436 #[doc = "QMem RAM"]
23437 #[inline(always)]
23438 pub fn set_qmem_ram(&mut self, val: u32) {
23439 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23440 }
23441 }
23442 impl Default for Qmem115 {
23443 #[inline(always)]
23444 fn default() -> Qmem115 {
23445 Qmem115(0)
23446 }
23447 }
23448 impl core::fmt::Debug for Qmem115 {
23449 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23450 f.debug_struct("Qmem115").field("qmem_ram", &self.qmem_ram()).finish()
23451 }
23452 }
23453 #[cfg(feature = "defmt")]
23454 impl defmt::Format for Qmem115 {
23455 fn format(&self, f: defmt::Formatter) {
23456 #[derive(defmt :: Format)]
23457 struct Qmem115 {
23458 qmem_ram: u32,
23459 }
23460 let proxy = Qmem115 {
23461 qmem_ram: self.qmem_ram(),
23462 };
23463 defmt::write!(f, "{}", proxy)
23464 }
23465 }
23466 #[doc = "JPEG quantization tables"]
23467 #[repr(transparent)]
23468 #[derive(Copy, Clone, Eq, PartialEq)]
23469 pub struct Qmem12(pub u32);
23470 impl Qmem12 {
23471 #[doc = "QMem RAM"]
23472 #[inline(always)]
23473 pub const fn qmem_ram(&self) -> u32 {
23474 let val = (self.0 >> 0usize) & 0xffff_ffff;
23475 val as u32
23476 }
23477 #[doc = "QMem RAM"]
23478 #[inline(always)]
23479 pub fn set_qmem_ram(&mut self, val: u32) {
23480 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23481 }
23482 }
23483 impl Default for Qmem12 {
23484 #[inline(always)]
23485 fn default() -> Qmem12 {
23486 Qmem12(0)
23487 }
23488 }
23489 impl core::fmt::Debug for Qmem12 {
23490 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23491 f.debug_struct("Qmem12").field("qmem_ram", &self.qmem_ram()).finish()
23492 }
23493 }
23494 #[cfg(feature = "defmt")]
23495 impl defmt::Format for Qmem12 {
23496 fn format(&self, f: defmt::Formatter) {
23497 #[derive(defmt :: Format)]
23498 struct Qmem12 {
23499 qmem_ram: u32,
23500 }
23501 let proxy = Qmem12 {
23502 qmem_ram: self.qmem_ram(),
23503 };
23504 defmt::write!(f, "{}", proxy)
23505 }
23506 }
23507 #[doc = "JPEG quantization tables"]
23508 #[repr(transparent)]
23509 #[derive(Copy, Clone, Eq, PartialEq)]
23510 pub struct Qmem13(pub u32);
23511 impl Qmem13 {
23512 #[doc = "QMem RAM"]
23513 #[inline(always)]
23514 pub const fn qmem_ram(&self) -> u32 {
23515 let val = (self.0 >> 0usize) & 0xffff_ffff;
23516 val as u32
23517 }
23518 #[doc = "QMem RAM"]
23519 #[inline(always)]
23520 pub fn set_qmem_ram(&mut self, val: u32) {
23521 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23522 }
23523 }
23524 impl Default for Qmem13 {
23525 #[inline(always)]
23526 fn default() -> Qmem13 {
23527 Qmem13(0)
23528 }
23529 }
23530 impl core::fmt::Debug for Qmem13 {
23531 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23532 f.debug_struct("Qmem13").field("qmem_ram", &self.qmem_ram()).finish()
23533 }
23534 }
23535 #[cfg(feature = "defmt")]
23536 impl defmt::Format for Qmem13 {
23537 fn format(&self, f: defmt::Formatter) {
23538 #[derive(defmt :: Format)]
23539 struct Qmem13 {
23540 qmem_ram: u32,
23541 }
23542 let proxy = Qmem13 {
23543 qmem_ram: self.qmem_ram(),
23544 };
23545 defmt::write!(f, "{}", proxy)
23546 }
23547 }
23548 #[doc = "JPEG quantization tables"]
23549 #[repr(transparent)]
23550 #[derive(Copy, Clone, Eq, PartialEq)]
23551 pub struct Qmem14(pub u32);
23552 impl Qmem14 {
23553 #[doc = "QMem RAM"]
23554 #[inline(always)]
23555 pub const fn qmem_ram(&self) -> u32 {
23556 let val = (self.0 >> 0usize) & 0xffff_ffff;
23557 val as u32
23558 }
23559 #[doc = "QMem RAM"]
23560 #[inline(always)]
23561 pub fn set_qmem_ram(&mut self, val: u32) {
23562 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23563 }
23564 }
23565 impl Default for Qmem14 {
23566 #[inline(always)]
23567 fn default() -> Qmem14 {
23568 Qmem14(0)
23569 }
23570 }
23571 impl core::fmt::Debug for Qmem14 {
23572 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23573 f.debug_struct("Qmem14").field("qmem_ram", &self.qmem_ram()).finish()
23574 }
23575 }
23576 #[cfg(feature = "defmt")]
23577 impl defmt::Format for Qmem14 {
23578 fn format(&self, f: defmt::Formatter) {
23579 #[derive(defmt :: Format)]
23580 struct Qmem14 {
23581 qmem_ram: u32,
23582 }
23583 let proxy = Qmem14 {
23584 qmem_ram: self.qmem_ram(),
23585 };
23586 defmt::write!(f, "{}", proxy)
23587 }
23588 }
23589 #[doc = "JPEG quantization tables"]
23590 #[repr(transparent)]
23591 #[derive(Copy, Clone, Eq, PartialEq)]
23592 pub struct Qmem15(pub u32);
23593 impl Qmem15 {
23594 #[doc = "QMem RAM"]
23595 #[inline(always)]
23596 pub const fn qmem_ram(&self) -> u32 {
23597 let val = (self.0 >> 0usize) & 0xffff_ffff;
23598 val as u32
23599 }
23600 #[doc = "QMem RAM"]
23601 #[inline(always)]
23602 pub fn set_qmem_ram(&mut self, val: u32) {
23603 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23604 }
23605 }
23606 impl Default for Qmem15 {
23607 #[inline(always)]
23608 fn default() -> Qmem15 {
23609 Qmem15(0)
23610 }
23611 }
23612 impl core::fmt::Debug for Qmem15 {
23613 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23614 f.debug_struct("Qmem15").field("qmem_ram", &self.qmem_ram()).finish()
23615 }
23616 }
23617 #[cfg(feature = "defmt")]
23618 impl defmt::Format for Qmem15 {
23619 fn format(&self, f: defmt::Formatter) {
23620 #[derive(defmt :: Format)]
23621 struct Qmem15 {
23622 qmem_ram: u32,
23623 }
23624 let proxy = Qmem15 {
23625 qmem_ram: self.qmem_ram(),
23626 };
23627 defmt::write!(f, "{}", proxy)
23628 }
23629 }
23630 #[doc = "JPEG quantization tables"]
23631 #[repr(transparent)]
23632 #[derive(Copy, Clone, Eq, PartialEq)]
23633 pub struct Qmem16(pub u32);
23634 impl Qmem16 {
23635 #[doc = "QMem RAM"]
23636 #[inline(always)]
23637 pub const fn qmem_ram(&self) -> u32 {
23638 let val = (self.0 >> 0usize) & 0xffff_ffff;
23639 val as u32
23640 }
23641 #[doc = "QMem RAM"]
23642 #[inline(always)]
23643 pub fn set_qmem_ram(&mut self, val: u32) {
23644 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23645 }
23646 }
23647 impl Default for Qmem16 {
23648 #[inline(always)]
23649 fn default() -> Qmem16 {
23650 Qmem16(0)
23651 }
23652 }
23653 impl core::fmt::Debug for Qmem16 {
23654 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23655 f.debug_struct("Qmem16").field("qmem_ram", &self.qmem_ram()).finish()
23656 }
23657 }
23658 #[cfg(feature = "defmt")]
23659 impl defmt::Format for Qmem16 {
23660 fn format(&self, f: defmt::Formatter) {
23661 #[derive(defmt :: Format)]
23662 struct Qmem16 {
23663 qmem_ram: u32,
23664 }
23665 let proxy = Qmem16 {
23666 qmem_ram: self.qmem_ram(),
23667 };
23668 defmt::write!(f, "{}", proxy)
23669 }
23670 }
23671 #[doc = "JPEG quantization tables"]
23672 #[repr(transparent)]
23673 #[derive(Copy, Clone, Eq, PartialEq)]
23674 pub struct Qmem17(pub u32);
23675 impl Qmem17 {
23676 #[doc = "QMem RAM"]
23677 #[inline(always)]
23678 pub const fn qmem_ram(&self) -> u32 {
23679 let val = (self.0 >> 0usize) & 0xffff_ffff;
23680 val as u32
23681 }
23682 #[doc = "QMem RAM"]
23683 #[inline(always)]
23684 pub fn set_qmem_ram(&mut self, val: u32) {
23685 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23686 }
23687 }
23688 impl Default for Qmem17 {
23689 #[inline(always)]
23690 fn default() -> Qmem17 {
23691 Qmem17(0)
23692 }
23693 }
23694 impl core::fmt::Debug for Qmem17 {
23695 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23696 f.debug_struct("Qmem17").field("qmem_ram", &self.qmem_ram()).finish()
23697 }
23698 }
23699 #[cfg(feature = "defmt")]
23700 impl defmt::Format for Qmem17 {
23701 fn format(&self, f: defmt::Formatter) {
23702 #[derive(defmt :: Format)]
23703 struct Qmem17 {
23704 qmem_ram: u32,
23705 }
23706 let proxy = Qmem17 {
23707 qmem_ram: self.qmem_ram(),
23708 };
23709 defmt::write!(f, "{}", proxy)
23710 }
23711 }
23712 #[doc = "JPEG quantization tables"]
23713 #[repr(transparent)]
23714 #[derive(Copy, Clone, Eq, PartialEq)]
23715 pub struct Qmem18(pub u32);
23716 impl Qmem18 {
23717 #[doc = "QMem RAM"]
23718 #[inline(always)]
23719 pub const fn qmem_ram(&self) -> u32 {
23720 let val = (self.0 >> 0usize) & 0xffff_ffff;
23721 val as u32
23722 }
23723 #[doc = "QMem RAM"]
23724 #[inline(always)]
23725 pub fn set_qmem_ram(&mut self, val: u32) {
23726 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23727 }
23728 }
23729 impl Default for Qmem18 {
23730 #[inline(always)]
23731 fn default() -> Qmem18 {
23732 Qmem18(0)
23733 }
23734 }
23735 impl core::fmt::Debug for Qmem18 {
23736 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23737 f.debug_struct("Qmem18").field("qmem_ram", &self.qmem_ram()).finish()
23738 }
23739 }
23740 #[cfg(feature = "defmt")]
23741 impl defmt::Format for Qmem18 {
23742 fn format(&self, f: defmt::Formatter) {
23743 #[derive(defmt :: Format)]
23744 struct Qmem18 {
23745 qmem_ram: u32,
23746 }
23747 let proxy = Qmem18 {
23748 qmem_ram: self.qmem_ram(),
23749 };
23750 defmt::write!(f, "{}", proxy)
23751 }
23752 }
23753 #[doc = "JPEG quantization tables"]
23754 #[repr(transparent)]
23755 #[derive(Copy, Clone, Eq, PartialEq)]
23756 pub struct Qmem19(pub u32);
23757 impl Qmem19 {
23758 #[doc = "QMem RAM"]
23759 #[inline(always)]
23760 pub const fn qmem_ram(&self) -> u32 {
23761 let val = (self.0 >> 0usize) & 0xffff_ffff;
23762 val as u32
23763 }
23764 #[doc = "QMem RAM"]
23765 #[inline(always)]
23766 pub fn set_qmem_ram(&mut self, val: u32) {
23767 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23768 }
23769 }
23770 impl Default for Qmem19 {
23771 #[inline(always)]
23772 fn default() -> Qmem19 {
23773 Qmem19(0)
23774 }
23775 }
23776 impl core::fmt::Debug for Qmem19 {
23777 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23778 f.debug_struct("Qmem19").field("qmem_ram", &self.qmem_ram()).finish()
23779 }
23780 }
23781 #[cfg(feature = "defmt")]
23782 impl defmt::Format for Qmem19 {
23783 fn format(&self, f: defmt::Formatter) {
23784 #[derive(defmt :: Format)]
23785 struct Qmem19 {
23786 qmem_ram: u32,
23787 }
23788 let proxy = Qmem19 {
23789 qmem_ram: self.qmem_ram(),
23790 };
23791 defmt::write!(f, "{}", proxy)
23792 }
23793 }
23794 #[doc = "JPEG quantization tables"]
23795 #[repr(transparent)]
23796 #[derive(Copy, Clone, Eq, PartialEq)]
23797 pub struct Qmem20(pub u32);
23798 impl Qmem20 {
23799 #[doc = "QMem RAM"]
23800 #[inline(always)]
23801 pub const fn qmem_ram(&self) -> u32 {
23802 let val = (self.0 >> 0usize) & 0xffff_ffff;
23803 val as u32
23804 }
23805 #[doc = "QMem RAM"]
23806 #[inline(always)]
23807 pub fn set_qmem_ram(&mut self, val: u32) {
23808 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23809 }
23810 }
23811 impl Default for Qmem20 {
23812 #[inline(always)]
23813 fn default() -> Qmem20 {
23814 Qmem20(0)
23815 }
23816 }
23817 impl core::fmt::Debug for Qmem20 {
23818 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23819 f.debug_struct("Qmem20").field("qmem_ram", &self.qmem_ram()).finish()
23820 }
23821 }
23822 #[cfg(feature = "defmt")]
23823 impl defmt::Format for Qmem20 {
23824 fn format(&self, f: defmt::Formatter) {
23825 #[derive(defmt :: Format)]
23826 struct Qmem20 {
23827 qmem_ram: u32,
23828 }
23829 let proxy = Qmem20 {
23830 qmem_ram: self.qmem_ram(),
23831 };
23832 defmt::write!(f, "{}", proxy)
23833 }
23834 }
23835 #[doc = "JPEG quantization tables"]
23836 #[repr(transparent)]
23837 #[derive(Copy, Clone, Eq, PartialEq)]
23838 pub struct Qmem21(pub u32);
23839 impl Qmem21 {
23840 #[doc = "QMem RAM"]
23841 #[inline(always)]
23842 pub const fn qmem_ram(&self) -> u32 {
23843 let val = (self.0 >> 0usize) & 0xffff_ffff;
23844 val as u32
23845 }
23846 #[doc = "QMem RAM"]
23847 #[inline(always)]
23848 pub fn set_qmem_ram(&mut self, val: u32) {
23849 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23850 }
23851 }
23852 impl Default for Qmem21 {
23853 #[inline(always)]
23854 fn default() -> Qmem21 {
23855 Qmem21(0)
23856 }
23857 }
23858 impl core::fmt::Debug for Qmem21 {
23859 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23860 f.debug_struct("Qmem21").field("qmem_ram", &self.qmem_ram()).finish()
23861 }
23862 }
23863 #[cfg(feature = "defmt")]
23864 impl defmt::Format for Qmem21 {
23865 fn format(&self, f: defmt::Formatter) {
23866 #[derive(defmt :: Format)]
23867 struct Qmem21 {
23868 qmem_ram: u32,
23869 }
23870 let proxy = Qmem21 {
23871 qmem_ram: self.qmem_ram(),
23872 };
23873 defmt::write!(f, "{}", proxy)
23874 }
23875 }
23876 #[doc = "JPEG quantization tables"]
23877 #[repr(transparent)]
23878 #[derive(Copy, Clone, Eq, PartialEq)]
23879 pub struct Qmem210(pub u32);
23880 impl Qmem210 {
23881 #[doc = "QMem RAM"]
23882 #[inline(always)]
23883 pub const fn qmem_ram(&self) -> u32 {
23884 let val = (self.0 >> 0usize) & 0xffff_ffff;
23885 val as u32
23886 }
23887 #[doc = "QMem RAM"]
23888 #[inline(always)]
23889 pub fn set_qmem_ram(&mut self, val: u32) {
23890 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23891 }
23892 }
23893 impl Default for Qmem210 {
23894 #[inline(always)]
23895 fn default() -> Qmem210 {
23896 Qmem210(0)
23897 }
23898 }
23899 impl core::fmt::Debug for Qmem210 {
23900 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23901 f.debug_struct("Qmem210").field("qmem_ram", &self.qmem_ram()).finish()
23902 }
23903 }
23904 #[cfg(feature = "defmt")]
23905 impl defmt::Format for Qmem210 {
23906 fn format(&self, f: defmt::Formatter) {
23907 #[derive(defmt :: Format)]
23908 struct Qmem210 {
23909 qmem_ram: u32,
23910 }
23911 let proxy = Qmem210 {
23912 qmem_ram: self.qmem_ram(),
23913 };
23914 defmt::write!(f, "{}", proxy)
23915 }
23916 }
23917 #[doc = "JPEG quantization tables"]
23918 #[repr(transparent)]
23919 #[derive(Copy, Clone, Eq, PartialEq)]
23920 pub struct Qmem211(pub u32);
23921 impl Qmem211 {
23922 #[doc = "QMem RAM"]
23923 #[inline(always)]
23924 pub const fn qmem_ram(&self) -> u32 {
23925 let val = (self.0 >> 0usize) & 0xffff_ffff;
23926 val as u32
23927 }
23928 #[doc = "QMem RAM"]
23929 #[inline(always)]
23930 pub fn set_qmem_ram(&mut self, val: u32) {
23931 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23932 }
23933 }
23934 impl Default for Qmem211 {
23935 #[inline(always)]
23936 fn default() -> Qmem211 {
23937 Qmem211(0)
23938 }
23939 }
23940 impl core::fmt::Debug for Qmem211 {
23941 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23942 f.debug_struct("Qmem211").field("qmem_ram", &self.qmem_ram()).finish()
23943 }
23944 }
23945 #[cfg(feature = "defmt")]
23946 impl defmt::Format for Qmem211 {
23947 fn format(&self, f: defmt::Formatter) {
23948 #[derive(defmt :: Format)]
23949 struct Qmem211 {
23950 qmem_ram: u32,
23951 }
23952 let proxy = Qmem211 {
23953 qmem_ram: self.qmem_ram(),
23954 };
23955 defmt::write!(f, "{}", proxy)
23956 }
23957 }
23958 #[doc = "JPEG quantization tables"]
23959 #[repr(transparent)]
23960 #[derive(Copy, Clone, Eq, PartialEq)]
23961 pub struct Qmem212(pub u32);
23962 impl Qmem212 {
23963 #[doc = "QMem RAM"]
23964 #[inline(always)]
23965 pub const fn qmem_ram(&self) -> u32 {
23966 let val = (self.0 >> 0usize) & 0xffff_ffff;
23967 val as u32
23968 }
23969 #[doc = "QMem RAM"]
23970 #[inline(always)]
23971 pub fn set_qmem_ram(&mut self, val: u32) {
23972 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
23973 }
23974 }
23975 impl Default for Qmem212 {
23976 #[inline(always)]
23977 fn default() -> Qmem212 {
23978 Qmem212(0)
23979 }
23980 }
23981 impl core::fmt::Debug for Qmem212 {
23982 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
23983 f.debug_struct("Qmem212").field("qmem_ram", &self.qmem_ram()).finish()
23984 }
23985 }
23986 #[cfg(feature = "defmt")]
23987 impl defmt::Format for Qmem212 {
23988 fn format(&self, f: defmt::Formatter) {
23989 #[derive(defmt :: Format)]
23990 struct Qmem212 {
23991 qmem_ram: u32,
23992 }
23993 let proxy = Qmem212 {
23994 qmem_ram: self.qmem_ram(),
23995 };
23996 defmt::write!(f, "{}", proxy)
23997 }
23998 }
23999 #[doc = "JPEG quantization tables"]
24000 #[repr(transparent)]
24001 #[derive(Copy, Clone, Eq, PartialEq)]
24002 pub struct Qmem213(pub u32);
24003 impl Qmem213 {
24004 #[doc = "QMem RAM"]
24005 #[inline(always)]
24006 pub const fn qmem_ram(&self) -> u32 {
24007 let val = (self.0 >> 0usize) & 0xffff_ffff;
24008 val as u32
24009 }
24010 #[doc = "QMem RAM"]
24011 #[inline(always)]
24012 pub fn set_qmem_ram(&mut self, val: u32) {
24013 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24014 }
24015 }
24016 impl Default for Qmem213 {
24017 #[inline(always)]
24018 fn default() -> Qmem213 {
24019 Qmem213(0)
24020 }
24021 }
24022 impl core::fmt::Debug for Qmem213 {
24023 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24024 f.debug_struct("Qmem213").field("qmem_ram", &self.qmem_ram()).finish()
24025 }
24026 }
24027 #[cfg(feature = "defmt")]
24028 impl defmt::Format for Qmem213 {
24029 fn format(&self, f: defmt::Formatter) {
24030 #[derive(defmt :: Format)]
24031 struct Qmem213 {
24032 qmem_ram: u32,
24033 }
24034 let proxy = Qmem213 {
24035 qmem_ram: self.qmem_ram(),
24036 };
24037 defmt::write!(f, "{}", proxy)
24038 }
24039 }
24040 #[doc = "JPEG quantization tables"]
24041 #[repr(transparent)]
24042 #[derive(Copy, Clone, Eq, PartialEq)]
24043 pub struct Qmem214(pub u32);
24044 impl Qmem214 {
24045 #[doc = "QMem RAM"]
24046 #[inline(always)]
24047 pub const fn qmem_ram(&self) -> u32 {
24048 let val = (self.0 >> 0usize) & 0xffff_ffff;
24049 val as u32
24050 }
24051 #[doc = "QMem RAM"]
24052 #[inline(always)]
24053 pub fn set_qmem_ram(&mut self, val: u32) {
24054 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24055 }
24056 }
24057 impl Default for Qmem214 {
24058 #[inline(always)]
24059 fn default() -> Qmem214 {
24060 Qmem214(0)
24061 }
24062 }
24063 impl core::fmt::Debug for Qmem214 {
24064 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24065 f.debug_struct("Qmem214").field("qmem_ram", &self.qmem_ram()).finish()
24066 }
24067 }
24068 #[cfg(feature = "defmt")]
24069 impl defmt::Format for Qmem214 {
24070 fn format(&self, f: defmt::Formatter) {
24071 #[derive(defmt :: Format)]
24072 struct Qmem214 {
24073 qmem_ram: u32,
24074 }
24075 let proxy = Qmem214 {
24076 qmem_ram: self.qmem_ram(),
24077 };
24078 defmt::write!(f, "{}", proxy)
24079 }
24080 }
24081 #[doc = "JPEG quantization tables"]
24082 #[repr(transparent)]
24083 #[derive(Copy, Clone, Eq, PartialEq)]
24084 pub struct Qmem215(pub u32);
24085 impl Qmem215 {
24086 #[doc = "QMem RAM"]
24087 #[inline(always)]
24088 pub const fn qmem_ram(&self) -> u32 {
24089 let val = (self.0 >> 0usize) & 0xffff_ffff;
24090 val as u32
24091 }
24092 #[doc = "QMem RAM"]
24093 #[inline(always)]
24094 pub fn set_qmem_ram(&mut self, val: u32) {
24095 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24096 }
24097 }
24098 impl Default for Qmem215 {
24099 #[inline(always)]
24100 fn default() -> Qmem215 {
24101 Qmem215(0)
24102 }
24103 }
24104 impl core::fmt::Debug for Qmem215 {
24105 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24106 f.debug_struct("Qmem215").field("qmem_ram", &self.qmem_ram()).finish()
24107 }
24108 }
24109 #[cfg(feature = "defmt")]
24110 impl defmt::Format for Qmem215 {
24111 fn format(&self, f: defmt::Formatter) {
24112 #[derive(defmt :: Format)]
24113 struct Qmem215 {
24114 qmem_ram: u32,
24115 }
24116 let proxy = Qmem215 {
24117 qmem_ram: self.qmem_ram(),
24118 };
24119 defmt::write!(f, "{}", proxy)
24120 }
24121 }
24122 #[doc = "JPEG quantization tables"]
24123 #[repr(transparent)]
24124 #[derive(Copy, Clone, Eq, PartialEq)]
24125 pub struct Qmem22(pub u32);
24126 impl Qmem22 {
24127 #[doc = "QMem RAM"]
24128 #[inline(always)]
24129 pub const fn qmem_ram(&self) -> u32 {
24130 let val = (self.0 >> 0usize) & 0xffff_ffff;
24131 val as u32
24132 }
24133 #[doc = "QMem RAM"]
24134 #[inline(always)]
24135 pub fn set_qmem_ram(&mut self, val: u32) {
24136 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24137 }
24138 }
24139 impl Default for Qmem22 {
24140 #[inline(always)]
24141 fn default() -> Qmem22 {
24142 Qmem22(0)
24143 }
24144 }
24145 impl core::fmt::Debug for Qmem22 {
24146 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24147 f.debug_struct("Qmem22").field("qmem_ram", &self.qmem_ram()).finish()
24148 }
24149 }
24150 #[cfg(feature = "defmt")]
24151 impl defmt::Format for Qmem22 {
24152 fn format(&self, f: defmt::Formatter) {
24153 #[derive(defmt :: Format)]
24154 struct Qmem22 {
24155 qmem_ram: u32,
24156 }
24157 let proxy = Qmem22 {
24158 qmem_ram: self.qmem_ram(),
24159 };
24160 defmt::write!(f, "{}", proxy)
24161 }
24162 }
24163 #[doc = "JPEG quantization tables"]
24164 #[repr(transparent)]
24165 #[derive(Copy, Clone, Eq, PartialEq)]
24166 pub struct Qmem23(pub u32);
24167 impl Qmem23 {
24168 #[doc = "QMem RAM"]
24169 #[inline(always)]
24170 pub const fn qmem_ram(&self) -> u32 {
24171 let val = (self.0 >> 0usize) & 0xffff_ffff;
24172 val as u32
24173 }
24174 #[doc = "QMem RAM"]
24175 #[inline(always)]
24176 pub fn set_qmem_ram(&mut self, val: u32) {
24177 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24178 }
24179 }
24180 impl Default for Qmem23 {
24181 #[inline(always)]
24182 fn default() -> Qmem23 {
24183 Qmem23(0)
24184 }
24185 }
24186 impl core::fmt::Debug for Qmem23 {
24187 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24188 f.debug_struct("Qmem23").field("qmem_ram", &self.qmem_ram()).finish()
24189 }
24190 }
24191 #[cfg(feature = "defmt")]
24192 impl defmt::Format for Qmem23 {
24193 fn format(&self, f: defmt::Formatter) {
24194 #[derive(defmt :: Format)]
24195 struct Qmem23 {
24196 qmem_ram: u32,
24197 }
24198 let proxy = Qmem23 {
24199 qmem_ram: self.qmem_ram(),
24200 };
24201 defmt::write!(f, "{}", proxy)
24202 }
24203 }
24204 #[doc = "JPEG quantization tables"]
24205 #[repr(transparent)]
24206 #[derive(Copy, Clone, Eq, PartialEq)]
24207 pub struct Qmem24(pub u32);
24208 impl Qmem24 {
24209 #[doc = "QMem RAM"]
24210 #[inline(always)]
24211 pub const fn qmem_ram(&self) -> u32 {
24212 let val = (self.0 >> 0usize) & 0xffff_ffff;
24213 val as u32
24214 }
24215 #[doc = "QMem RAM"]
24216 #[inline(always)]
24217 pub fn set_qmem_ram(&mut self, val: u32) {
24218 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24219 }
24220 }
24221 impl Default for Qmem24 {
24222 #[inline(always)]
24223 fn default() -> Qmem24 {
24224 Qmem24(0)
24225 }
24226 }
24227 impl core::fmt::Debug for Qmem24 {
24228 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24229 f.debug_struct("Qmem24").field("qmem_ram", &self.qmem_ram()).finish()
24230 }
24231 }
24232 #[cfg(feature = "defmt")]
24233 impl defmt::Format for Qmem24 {
24234 fn format(&self, f: defmt::Formatter) {
24235 #[derive(defmt :: Format)]
24236 struct Qmem24 {
24237 qmem_ram: u32,
24238 }
24239 let proxy = Qmem24 {
24240 qmem_ram: self.qmem_ram(),
24241 };
24242 defmt::write!(f, "{}", proxy)
24243 }
24244 }
24245 #[doc = "JPEG quantization tables"]
24246 #[repr(transparent)]
24247 #[derive(Copy, Clone, Eq, PartialEq)]
24248 pub struct Qmem25(pub u32);
24249 impl Qmem25 {
24250 #[doc = "QMem RAM"]
24251 #[inline(always)]
24252 pub const fn qmem_ram(&self) -> u32 {
24253 let val = (self.0 >> 0usize) & 0xffff_ffff;
24254 val as u32
24255 }
24256 #[doc = "QMem RAM"]
24257 #[inline(always)]
24258 pub fn set_qmem_ram(&mut self, val: u32) {
24259 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24260 }
24261 }
24262 impl Default for Qmem25 {
24263 #[inline(always)]
24264 fn default() -> Qmem25 {
24265 Qmem25(0)
24266 }
24267 }
24268 impl core::fmt::Debug for Qmem25 {
24269 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24270 f.debug_struct("Qmem25").field("qmem_ram", &self.qmem_ram()).finish()
24271 }
24272 }
24273 #[cfg(feature = "defmt")]
24274 impl defmt::Format for Qmem25 {
24275 fn format(&self, f: defmt::Formatter) {
24276 #[derive(defmt :: Format)]
24277 struct Qmem25 {
24278 qmem_ram: u32,
24279 }
24280 let proxy = Qmem25 {
24281 qmem_ram: self.qmem_ram(),
24282 };
24283 defmt::write!(f, "{}", proxy)
24284 }
24285 }
24286 #[doc = "JPEG quantization tables"]
24287 #[repr(transparent)]
24288 #[derive(Copy, Clone, Eq, PartialEq)]
24289 pub struct Qmem26(pub u32);
24290 impl Qmem26 {
24291 #[doc = "QMem RAM"]
24292 #[inline(always)]
24293 pub const fn qmem_ram(&self) -> u32 {
24294 let val = (self.0 >> 0usize) & 0xffff_ffff;
24295 val as u32
24296 }
24297 #[doc = "QMem RAM"]
24298 #[inline(always)]
24299 pub fn set_qmem_ram(&mut self, val: u32) {
24300 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24301 }
24302 }
24303 impl Default for Qmem26 {
24304 #[inline(always)]
24305 fn default() -> Qmem26 {
24306 Qmem26(0)
24307 }
24308 }
24309 impl core::fmt::Debug for Qmem26 {
24310 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24311 f.debug_struct("Qmem26").field("qmem_ram", &self.qmem_ram()).finish()
24312 }
24313 }
24314 #[cfg(feature = "defmt")]
24315 impl defmt::Format for Qmem26 {
24316 fn format(&self, f: defmt::Formatter) {
24317 #[derive(defmt :: Format)]
24318 struct Qmem26 {
24319 qmem_ram: u32,
24320 }
24321 let proxy = Qmem26 {
24322 qmem_ram: self.qmem_ram(),
24323 };
24324 defmt::write!(f, "{}", proxy)
24325 }
24326 }
24327 #[doc = "JPEG quantization tables"]
24328 #[repr(transparent)]
24329 #[derive(Copy, Clone, Eq, PartialEq)]
24330 pub struct Qmem27(pub u32);
24331 impl Qmem27 {
24332 #[doc = "QMem RAM"]
24333 #[inline(always)]
24334 pub const fn qmem_ram(&self) -> u32 {
24335 let val = (self.0 >> 0usize) & 0xffff_ffff;
24336 val as u32
24337 }
24338 #[doc = "QMem RAM"]
24339 #[inline(always)]
24340 pub fn set_qmem_ram(&mut self, val: u32) {
24341 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24342 }
24343 }
24344 impl Default for Qmem27 {
24345 #[inline(always)]
24346 fn default() -> Qmem27 {
24347 Qmem27(0)
24348 }
24349 }
24350 impl core::fmt::Debug for Qmem27 {
24351 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24352 f.debug_struct("Qmem27").field("qmem_ram", &self.qmem_ram()).finish()
24353 }
24354 }
24355 #[cfg(feature = "defmt")]
24356 impl defmt::Format for Qmem27 {
24357 fn format(&self, f: defmt::Formatter) {
24358 #[derive(defmt :: Format)]
24359 struct Qmem27 {
24360 qmem_ram: u32,
24361 }
24362 let proxy = Qmem27 {
24363 qmem_ram: self.qmem_ram(),
24364 };
24365 defmt::write!(f, "{}", proxy)
24366 }
24367 }
24368 #[doc = "JPEG quantization tables"]
24369 #[repr(transparent)]
24370 #[derive(Copy, Clone, Eq, PartialEq)]
24371 pub struct Qmem28(pub u32);
24372 impl Qmem28 {
24373 #[doc = "QMem RAM"]
24374 #[inline(always)]
24375 pub const fn qmem_ram(&self) -> u32 {
24376 let val = (self.0 >> 0usize) & 0xffff_ffff;
24377 val as u32
24378 }
24379 #[doc = "QMem RAM"]
24380 #[inline(always)]
24381 pub fn set_qmem_ram(&mut self, val: u32) {
24382 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24383 }
24384 }
24385 impl Default for Qmem28 {
24386 #[inline(always)]
24387 fn default() -> Qmem28 {
24388 Qmem28(0)
24389 }
24390 }
24391 impl core::fmt::Debug for Qmem28 {
24392 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24393 f.debug_struct("Qmem28").field("qmem_ram", &self.qmem_ram()).finish()
24394 }
24395 }
24396 #[cfg(feature = "defmt")]
24397 impl defmt::Format for Qmem28 {
24398 fn format(&self, f: defmt::Formatter) {
24399 #[derive(defmt :: Format)]
24400 struct Qmem28 {
24401 qmem_ram: u32,
24402 }
24403 let proxy = Qmem28 {
24404 qmem_ram: self.qmem_ram(),
24405 };
24406 defmt::write!(f, "{}", proxy)
24407 }
24408 }
24409 #[doc = "JPEG quantization tables"]
24410 #[repr(transparent)]
24411 #[derive(Copy, Clone, Eq, PartialEq)]
24412 pub struct Qmem29(pub u32);
24413 impl Qmem29 {
24414 #[doc = "QMem RAM"]
24415 #[inline(always)]
24416 pub const fn qmem_ram(&self) -> u32 {
24417 let val = (self.0 >> 0usize) & 0xffff_ffff;
24418 val as u32
24419 }
24420 #[doc = "QMem RAM"]
24421 #[inline(always)]
24422 pub fn set_qmem_ram(&mut self, val: u32) {
24423 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24424 }
24425 }
24426 impl Default for Qmem29 {
24427 #[inline(always)]
24428 fn default() -> Qmem29 {
24429 Qmem29(0)
24430 }
24431 }
24432 impl core::fmt::Debug for Qmem29 {
24433 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24434 f.debug_struct("Qmem29").field("qmem_ram", &self.qmem_ram()).finish()
24435 }
24436 }
24437 #[cfg(feature = "defmt")]
24438 impl defmt::Format for Qmem29 {
24439 fn format(&self, f: defmt::Formatter) {
24440 #[derive(defmt :: Format)]
24441 struct Qmem29 {
24442 qmem_ram: u32,
24443 }
24444 let proxy = Qmem29 {
24445 qmem_ram: self.qmem_ram(),
24446 };
24447 defmt::write!(f, "{}", proxy)
24448 }
24449 }
24450 #[doc = "JPEG quantization tables"]
24451 #[repr(transparent)]
24452 #[derive(Copy, Clone, Eq, PartialEq)]
24453 pub struct Qmem30(pub u32);
24454 impl Qmem30 {
24455 #[doc = "QMem RAM"]
24456 #[inline(always)]
24457 pub const fn qmem_ram(&self) -> u32 {
24458 let val = (self.0 >> 0usize) & 0xffff_ffff;
24459 val as u32
24460 }
24461 #[doc = "QMem RAM"]
24462 #[inline(always)]
24463 pub fn set_qmem_ram(&mut self, val: u32) {
24464 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24465 }
24466 }
24467 impl Default for Qmem30 {
24468 #[inline(always)]
24469 fn default() -> Qmem30 {
24470 Qmem30(0)
24471 }
24472 }
24473 impl core::fmt::Debug for Qmem30 {
24474 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24475 f.debug_struct("Qmem30").field("qmem_ram", &self.qmem_ram()).finish()
24476 }
24477 }
24478 #[cfg(feature = "defmt")]
24479 impl defmt::Format for Qmem30 {
24480 fn format(&self, f: defmt::Formatter) {
24481 #[derive(defmt :: Format)]
24482 struct Qmem30 {
24483 qmem_ram: u32,
24484 }
24485 let proxy = Qmem30 {
24486 qmem_ram: self.qmem_ram(),
24487 };
24488 defmt::write!(f, "{}", proxy)
24489 }
24490 }
24491 #[doc = "JPEG quantization tables"]
24492 #[repr(transparent)]
24493 #[derive(Copy, Clone, Eq, PartialEq)]
24494 pub struct Qmem31(pub u32);
24495 impl Qmem31 {
24496 #[doc = "QMem RAM"]
24497 #[inline(always)]
24498 pub const fn qmem_ram(&self) -> u32 {
24499 let val = (self.0 >> 0usize) & 0xffff_ffff;
24500 val as u32
24501 }
24502 #[doc = "QMem RAM"]
24503 #[inline(always)]
24504 pub fn set_qmem_ram(&mut self, val: u32) {
24505 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24506 }
24507 }
24508 impl Default for Qmem31 {
24509 #[inline(always)]
24510 fn default() -> Qmem31 {
24511 Qmem31(0)
24512 }
24513 }
24514 impl core::fmt::Debug for Qmem31 {
24515 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24516 f.debug_struct("Qmem31").field("qmem_ram", &self.qmem_ram()).finish()
24517 }
24518 }
24519 #[cfg(feature = "defmt")]
24520 impl defmt::Format for Qmem31 {
24521 fn format(&self, f: defmt::Formatter) {
24522 #[derive(defmt :: Format)]
24523 struct Qmem31 {
24524 qmem_ram: u32,
24525 }
24526 let proxy = Qmem31 {
24527 qmem_ram: self.qmem_ram(),
24528 };
24529 defmt::write!(f, "{}", proxy)
24530 }
24531 }
24532 #[doc = "JPEG quantization tables"]
24533 #[repr(transparent)]
24534 #[derive(Copy, Clone, Eq, PartialEq)]
24535 pub struct Qmem310(pub u32);
24536 impl Qmem310 {
24537 #[doc = "QMem RAM"]
24538 #[inline(always)]
24539 pub const fn qmem_ram(&self) -> u32 {
24540 let val = (self.0 >> 0usize) & 0xffff_ffff;
24541 val as u32
24542 }
24543 #[doc = "QMem RAM"]
24544 #[inline(always)]
24545 pub fn set_qmem_ram(&mut self, val: u32) {
24546 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24547 }
24548 }
24549 impl Default for Qmem310 {
24550 #[inline(always)]
24551 fn default() -> Qmem310 {
24552 Qmem310(0)
24553 }
24554 }
24555 impl core::fmt::Debug for Qmem310 {
24556 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24557 f.debug_struct("Qmem310").field("qmem_ram", &self.qmem_ram()).finish()
24558 }
24559 }
24560 #[cfg(feature = "defmt")]
24561 impl defmt::Format for Qmem310 {
24562 fn format(&self, f: defmt::Formatter) {
24563 #[derive(defmt :: Format)]
24564 struct Qmem310 {
24565 qmem_ram: u32,
24566 }
24567 let proxy = Qmem310 {
24568 qmem_ram: self.qmem_ram(),
24569 };
24570 defmt::write!(f, "{}", proxy)
24571 }
24572 }
24573 #[doc = "JPEG quantization tables"]
24574 #[repr(transparent)]
24575 #[derive(Copy, Clone, Eq, PartialEq)]
24576 pub struct Qmem311(pub u32);
24577 impl Qmem311 {
24578 #[doc = "QMem RAM"]
24579 #[inline(always)]
24580 pub const fn qmem_ram(&self) -> u32 {
24581 let val = (self.0 >> 0usize) & 0xffff_ffff;
24582 val as u32
24583 }
24584 #[doc = "QMem RAM"]
24585 #[inline(always)]
24586 pub fn set_qmem_ram(&mut self, val: u32) {
24587 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24588 }
24589 }
24590 impl Default for Qmem311 {
24591 #[inline(always)]
24592 fn default() -> Qmem311 {
24593 Qmem311(0)
24594 }
24595 }
24596 impl core::fmt::Debug for Qmem311 {
24597 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24598 f.debug_struct("Qmem311").field("qmem_ram", &self.qmem_ram()).finish()
24599 }
24600 }
24601 #[cfg(feature = "defmt")]
24602 impl defmt::Format for Qmem311 {
24603 fn format(&self, f: defmt::Formatter) {
24604 #[derive(defmt :: Format)]
24605 struct Qmem311 {
24606 qmem_ram: u32,
24607 }
24608 let proxy = Qmem311 {
24609 qmem_ram: self.qmem_ram(),
24610 };
24611 defmt::write!(f, "{}", proxy)
24612 }
24613 }
24614 #[doc = "JPEG quantization tables"]
24615 #[repr(transparent)]
24616 #[derive(Copy, Clone, Eq, PartialEq)]
24617 pub struct Qmem312(pub u32);
24618 impl Qmem312 {
24619 #[doc = "QMem RAM"]
24620 #[inline(always)]
24621 pub const fn qmem_ram(&self) -> u32 {
24622 let val = (self.0 >> 0usize) & 0xffff_ffff;
24623 val as u32
24624 }
24625 #[doc = "QMem RAM"]
24626 #[inline(always)]
24627 pub fn set_qmem_ram(&mut self, val: u32) {
24628 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24629 }
24630 }
24631 impl Default for Qmem312 {
24632 #[inline(always)]
24633 fn default() -> Qmem312 {
24634 Qmem312(0)
24635 }
24636 }
24637 impl core::fmt::Debug for Qmem312 {
24638 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24639 f.debug_struct("Qmem312").field("qmem_ram", &self.qmem_ram()).finish()
24640 }
24641 }
24642 #[cfg(feature = "defmt")]
24643 impl defmt::Format for Qmem312 {
24644 fn format(&self, f: defmt::Formatter) {
24645 #[derive(defmt :: Format)]
24646 struct Qmem312 {
24647 qmem_ram: u32,
24648 }
24649 let proxy = Qmem312 {
24650 qmem_ram: self.qmem_ram(),
24651 };
24652 defmt::write!(f, "{}", proxy)
24653 }
24654 }
24655 #[doc = "JPEG quantization tables"]
24656 #[repr(transparent)]
24657 #[derive(Copy, Clone, Eq, PartialEq)]
24658 pub struct Qmem313(pub u32);
24659 impl Qmem313 {
24660 #[doc = "QMem RAM"]
24661 #[inline(always)]
24662 pub const fn qmem_ram(&self) -> u32 {
24663 let val = (self.0 >> 0usize) & 0xffff_ffff;
24664 val as u32
24665 }
24666 #[doc = "QMem RAM"]
24667 #[inline(always)]
24668 pub fn set_qmem_ram(&mut self, val: u32) {
24669 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24670 }
24671 }
24672 impl Default for Qmem313 {
24673 #[inline(always)]
24674 fn default() -> Qmem313 {
24675 Qmem313(0)
24676 }
24677 }
24678 impl core::fmt::Debug for Qmem313 {
24679 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24680 f.debug_struct("Qmem313").field("qmem_ram", &self.qmem_ram()).finish()
24681 }
24682 }
24683 #[cfg(feature = "defmt")]
24684 impl defmt::Format for Qmem313 {
24685 fn format(&self, f: defmt::Formatter) {
24686 #[derive(defmt :: Format)]
24687 struct Qmem313 {
24688 qmem_ram: u32,
24689 }
24690 let proxy = Qmem313 {
24691 qmem_ram: self.qmem_ram(),
24692 };
24693 defmt::write!(f, "{}", proxy)
24694 }
24695 }
24696 #[doc = "JPEG quantization tables"]
24697 #[repr(transparent)]
24698 #[derive(Copy, Clone, Eq, PartialEq)]
24699 pub struct Qmem314(pub u32);
24700 impl Qmem314 {
24701 #[doc = "QMem RAM"]
24702 #[inline(always)]
24703 pub const fn qmem_ram(&self) -> u32 {
24704 let val = (self.0 >> 0usize) & 0xffff_ffff;
24705 val as u32
24706 }
24707 #[doc = "QMem RAM"]
24708 #[inline(always)]
24709 pub fn set_qmem_ram(&mut self, val: u32) {
24710 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24711 }
24712 }
24713 impl Default for Qmem314 {
24714 #[inline(always)]
24715 fn default() -> Qmem314 {
24716 Qmem314(0)
24717 }
24718 }
24719 impl core::fmt::Debug for Qmem314 {
24720 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24721 f.debug_struct("Qmem314").field("qmem_ram", &self.qmem_ram()).finish()
24722 }
24723 }
24724 #[cfg(feature = "defmt")]
24725 impl defmt::Format for Qmem314 {
24726 fn format(&self, f: defmt::Formatter) {
24727 #[derive(defmt :: Format)]
24728 struct Qmem314 {
24729 qmem_ram: u32,
24730 }
24731 let proxy = Qmem314 {
24732 qmem_ram: self.qmem_ram(),
24733 };
24734 defmt::write!(f, "{}", proxy)
24735 }
24736 }
24737 #[doc = "JPEG quantization tables"]
24738 #[repr(transparent)]
24739 #[derive(Copy, Clone, Eq, PartialEq)]
24740 pub struct Qmem315(pub u32);
24741 impl Qmem315 {
24742 #[doc = "QMem RAM"]
24743 #[inline(always)]
24744 pub const fn qmem_ram(&self) -> u32 {
24745 let val = (self.0 >> 0usize) & 0xffff_ffff;
24746 val as u32
24747 }
24748 #[doc = "QMem RAM"]
24749 #[inline(always)]
24750 pub fn set_qmem_ram(&mut self, val: u32) {
24751 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24752 }
24753 }
24754 impl Default for Qmem315 {
24755 #[inline(always)]
24756 fn default() -> Qmem315 {
24757 Qmem315(0)
24758 }
24759 }
24760 impl core::fmt::Debug for Qmem315 {
24761 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24762 f.debug_struct("Qmem315").field("qmem_ram", &self.qmem_ram()).finish()
24763 }
24764 }
24765 #[cfg(feature = "defmt")]
24766 impl defmt::Format for Qmem315 {
24767 fn format(&self, f: defmt::Formatter) {
24768 #[derive(defmt :: Format)]
24769 struct Qmem315 {
24770 qmem_ram: u32,
24771 }
24772 let proxy = Qmem315 {
24773 qmem_ram: self.qmem_ram(),
24774 };
24775 defmt::write!(f, "{}", proxy)
24776 }
24777 }
24778 #[doc = "JPEG quantization tables"]
24779 #[repr(transparent)]
24780 #[derive(Copy, Clone, Eq, PartialEq)]
24781 pub struct Qmem32(pub u32);
24782 impl Qmem32 {
24783 #[doc = "QMem RAM"]
24784 #[inline(always)]
24785 pub const fn qmem_ram(&self) -> u32 {
24786 let val = (self.0 >> 0usize) & 0xffff_ffff;
24787 val as u32
24788 }
24789 #[doc = "QMem RAM"]
24790 #[inline(always)]
24791 pub fn set_qmem_ram(&mut self, val: u32) {
24792 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24793 }
24794 }
24795 impl Default for Qmem32 {
24796 #[inline(always)]
24797 fn default() -> Qmem32 {
24798 Qmem32(0)
24799 }
24800 }
24801 impl core::fmt::Debug for Qmem32 {
24802 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24803 f.debug_struct("Qmem32").field("qmem_ram", &self.qmem_ram()).finish()
24804 }
24805 }
24806 #[cfg(feature = "defmt")]
24807 impl defmt::Format for Qmem32 {
24808 fn format(&self, f: defmt::Formatter) {
24809 #[derive(defmt :: Format)]
24810 struct Qmem32 {
24811 qmem_ram: u32,
24812 }
24813 let proxy = Qmem32 {
24814 qmem_ram: self.qmem_ram(),
24815 };
24816 defmt::write!(f, "{}", proxy)
24817 }
24818 }
24819 #[doc = "JPEG quantization tables"]
24820 #[repr(transparent)]
24821 #[derive(Copy, Clone, Eq, PartialEq)]
24822 pub struct Qmem33(pub u32);
24823 impl Qmem33 {
24824 #[doc = "QMem RAM"]
24825 #[inline(always)]
24826 pub const fn qmem_ram(&self) -> u32 {
24827 let val = (self.0 >> 0usize) & 0xffff_ffff;
24828 val as u32
24829 }
24830 #[doc = "QMem RAM"]
24831 #[inline(always)]
24832 pub fn set_qmem_ram(&mut self, val: u32) {
24833 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24834 }
24835 }
24836 impl Default for Qmem33 {
24837 #[inline(always)]
24838 fn default() -> Qmem33 {
24839 Qmem33(0)
24840 }
24841 }
24842 impl core::fmt::Debug for Qmem33 {
24843 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24844 f.debug_struct("Qmem33").field("qmem_ram", &self.qmem_ram()).finish()
24845 }
24846 }
24847 #[cfg(feature = "defmt")]
24848 impl defmt::Format for Qmem33 {
24849 fn format(&self, f: defmt::Formatter) {
24850 #[derive(defmt :: Format)]
24851 struct Qmem33 {
24852 qmem_ram: u32,
24853 }
24854 let proxy = Qmem33 {
24855 qmem_ram: self.qmem_ram(),
24856 };
24857 defmt::write!(f, "{}", proxy)
24858 }
24859 }
24860 #[doc = "JPEG quantization tables"]
24861 #[repr(transparent)]
24862 #[derive(Copy, Clone, Eq, PartialEq)]
24863 pub struct Qmem34(pub u32);
24864 impl Qmem34 {
24865 #[doc = "QMem RAM"]
24866 #[inline(always)]
24867 pub const fn qmem_ram(&self) -> u32 {
24868 let val = (self.0 >> 0usize) & 0xffff_ffff;
24869 val as u32
24870 }
24871 #[doc = "QMem RAM"]
24872 #[inline(always)]
24873 pub fn set_qmem_ram(&mut self, val: u32) {
24874 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24875 }
24876 }
24877 impl Default for Qmem34 {
24878 #[inline(always)]
24879 fn default() -> Qmem34 {
24880 Qmem34(0)
24881 }
24882 }
24883 impl core::fmt::Debug for Qmem34 {
24884 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24885 f.debug_struct("Qmem34").field("qmem_ram", &self.qmem_ram()).finish()
24886 }
24887 }
24888 #[cfg(feature = "defmt")]
24889 impl defmt::Format for Qmem34 {
24890 fn format(&self, f: defmt::Formatter) {
24891 #[derive(defmt :: Format)]
24892 struct Qmem34 {
24893 qmem_ram: u32,
24894 }
24895 let proxy = Qmem34 {
24896 qmem_ram: self.qmem_ram(),
24897 };
24898 defmt::write!(f, "{}", proxy)
24899 }
24900 }
24901 #[doc = "JPEG quantization tables"]
24902 #[repr(transparent)]
24903 #[derive(Copy, Clone, Eq, PartialEq)]
24904 pub struct Qmem35(pub u32);
24905 impl Qmem35 {
24906 #[doc = "QMem RAM"]
24907 #[inline(always)]
24908 pub const fn qmem_ram(&self) -> u32 {
24909 let val = (self.0 >> 0usize) & 0xffff_ffff;
24910 val as u32
24911 }
24912 #[doc = "QMem RAM"]
24913 #[inline(always)]
24914 pub fn set_qmem_ram(&mut self, val: u32) {
24915 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24916 }
24917 }
24918 impl Default for Qmem35 {
24919 #[inline(always)]
24920 fn default() -> Qmem35 {
24921 Qmem35(0)
24922 }
24923 }
24924 impl core::fmt::Debug for Qmem35 {
24925 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24926 f.debug_struct("Qmem35").field("qmem_ram", &self.qmem_ram()).finish()
24927 }
24928 }
24929 #[cfg(feature = "defmt")]
24930 impl defmt::Format for Qmem35 {
24931 fn format(&self, f: defmt::Formatter) {
24932 #[derive(defmt :: Format)]
24933 struct Qmem35 {
24934 qmem_ram: u32,
24935 }
24936 let proxy = Qmem35 {
24937 qmem_ram: self.qmem_ram(),
24938 };
24939 defmt::write!(f, "{}", proxy)
24940 }
24941 }
24942 #[doc = "JPEG quantization tables"]
24943 #[repr(transparent)]
24944 #[derive(Copy, Clone, Eq, PartialEq)]
24945 pub struct Qmem36(pub u32);
24946 impl Qmem36 {
24947 #[doc = "QMem RAM"]
24948 #[inline(always)]
24949 pub const fn qmem_ram(&self) -> u32 {
24950 let val = (self.0 >> 0usize) & 0xffff_ffff;
24951 val as u32
24952 }
24953 #[doc = "QMem RAM"]
24954 #[inline(always)]
24955 pub fn set_qmem_ram(&mut self, val: u32) {
24956 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24957 }
24958 }
24959 impl Default for Qmem36 {
24960 #[inline(always)]
24961 fn default() -> Qmem36 {
24962 Qmem36(0)
24963 }
24964 }
24965 impl core::fmt::Debug for Qmem36 {
24966 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
24967 f.debug_struct("Qmem36").field("qmem_ram", &self.qmem_ram()).finish()
24968 }
24969 }
24970 #[cfg(feature = "defmt")]
24971 impl defmt::Format for Qmem36 {
24972 fn format(&self, f: defmt::Formatter) {
24973 #[derive(defmt :: Format)]
24974 struct Qmem36 {
24975 qmem_ram: u32,
24976 }
24977 let proxy = Qmem36 {
24978 qmem_ram: self.qmem_ram(),
24979 };
24980 defmt::write!(f, "{}", proxy)
24981 }
24982 }
24983 #[doc = "JPEG quantization tables"]
24984 #[repr(transparent)]
24985 #[derive(Copy, Clone, Eq, PartialEq)]
24986 pub struct Qmem37(pub u32);
24987 impl Qmem37 {
24988 #[doc = "QMem RAM"]
24989 #[inline(always)]
24990 pub const fn qmem_ram(&self) -> u32 {
24991 let val = (self.0 >> 0usize) & 0xffff_ffff;
24992 val as u32
24993 }
24994 #[doc = "QMem RAM"]
24995 #[inline(always)]
24996 pub fn set_qmem_ram(&mut self, val: u32) {
24997 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
24998 }
24999 }
25000 impl Default for Qmem37 {
25001 #[inline(always)]
25002 fn default() -> Qmem37 {
25003 Qmem37(0)
25004 }
25005 }
25006 impl core::fmt::Debug for Qmem37 {
25007 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
25008 f.debug_struct("Qmem37").field("qmem_ram", &self.qmem_ram()).finish()
25009 }
25010 }
25011 #[cfg(feature = "defmt")]
25012 impl defmt::Format for Qmem37 {
25013 fn format(&self, f: defmt::Formatter) {
25014 #[derive(defmt :: Format)]
25015 struct Qmem37 {
25016 qmem_ram: u32,
25017 }
25018 let proxy = Qmem37 {
25019 qmem_ram: self.qmem_ram(),
25020 };
25021 defmt::write!(f, "{}", proxy)
25022 }
25023 }
25024 #[doc = "JPEG quantization tables"]
25025 #[repr(transparent)]
25026 #[derive(Copy, Clone, Eq, PartialEq)]
25027 pub struct Qmem38(pub u32);
25028 impl Qmem38 {
25029 #[doc = "QMem RAM"]
25030 #[inline(always)]
25031 pub const fn qmem_ram(&self) -> u32 {
25032 let val = (self.0 >> 0usize) & 0xffff_ffff;
25033 val as u32
25034 }
25035 #[doc = "QMem RAM"]
25036 #[inline(always)]
25037 pub fn set_qmem_ram(&mut self, val: u32) {
25038 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
25039 }
25040 }
25041 impl Default for Qmem38 {
25042 #[inline(always)]
25043 fn default() -> Qmem38 {
25044 Qmem38(0)
25045 }
25046 }
25047 impl core::fmt::Debug for Qmem38 {
25048 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
25049 f.debug_struct("Qmem38").field("qmem_ram", &self.qmem_ram()).finish()
25050 }
25051 }
25052 #[cfg(feature = "defmt")]
25053 impl defmt::Format for Qmem38 {
25054 fn format(&self, f: defmt::Formatter) {
25055 #[derive(defmt :: Format)]
25056 struct Qmem38 {
25057 qmem_ram: u32,
25058 }
25059 let proxy = Qmem38 {
25060 qmem_ram: self.qmem_ram(),
25061 };
25062 defmt::write!(f, "{}", proxy)
25063 }
25064 }
25065 #[doc = "JPEG quantization tables"]
25066 #[repr(transparent)]
25067 #[derive(Copy, Clone, Eq, PartialEq)]
25068 pub struct Qmem39(pub u32);
25069 impl Qmem39 {
25070 #[doc = "QMem RAM"]
25071 #[inline(always)]
25072 pub const fn qmem_ram(&self) -> u32 {
25073 let val = (self.0 >> 0usize) & 0xffff_ffff;
25074 val as u32
25075 }
25076 #[doc = "QMem RAM"]
25077 #[inline(always)]
25078 pub fn set_qmem_ram(&mut self, val: u32) {
25079 self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
25080 }
25081 }
25082 impl Default for Qmem39 {
25083 #[inline(always)]
25084 fn default() -> Qmem39 {
25085 Qmem39(0)
25086 }
25087 }
25088 impl core::fmt::Debug for Qmem39 {
25089 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
25090 f.debug_struct("Qmem39").field("qmem_ram", &self.qmem_ram()).finish()
25091 }
25092 }
25093 #[cfg(feature = "defmt")]
25094 impl defmt::Format for Qmem39 {
25095 fn format(&self, f: defmt::Formatter) {
25096 #[derive(defmt :: Format)]
25097 struct Qmem39 {
25098 qmem_ram: u32,
25099 }
25100 let proxy = Qmem39 {
25101 qmem_ram: self.qmem_ram(),
25102 };
25103 defmt::write!(f, "{}", proxy)
25104 }
25105 }
25106}
25107