OpenJPH
Open-source implementation of JPEG2000 Part-15
ojph_transform_wasm.cpp
Go to the documentation of this file.
1//***************************************************************************/
2// This software is released under the 2-Clause BSD license, included
3// below.
4//
5// Copyright (c) 2021, Aous Naman
6// Copyright (c) 2021, Kakadu Software Pty Ltd, Australia
7// Copyright (c) 2021, The University of New South Wales, Australia
8//
9// Redistribution and use in source and binary forms, with or without
10// modification, are permitted provided that the following conditions are
11// met:
12//
13// 1. Redistributions of source code must retain the above copyright
14// notice, this list of conditions and the following disclaimer.
15//
16// 2. Redistributions in binary form must reproduce the above copyright
17// notice, this list of conditions and the following disclaimer in the
18// documentation and/or other materials provided with the distribution.
19//
20// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
21// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
23// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
26// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31//***************************************************************************/
32// This file is part of the OpenJPH software implementation.
33// File: ojph_transform_wasm.cpp
34// Author: Aous Naman
35// Date: 09 February 2021
36//***************************************************************************/
37
38#include <cstdio>
39#include <wasm_simd128.h>
40
41#include "ojph_defs.h"
42#include "ojph_arch.h"
43#include "ojph_mem.h"
44#include "ojph_transform.h"
46
47namespace ojph {
48 namespace local {
49
52 const line_buf* line_src2,
53 line_buf *line_dst, ui32 repeat)
54 {
55 si32 *dst = line_dst->i32;
56 const si32 *src1 = line_src1->i32, *src2 = line_src2->i32;
57
58 for (ui32 i = (repeat + 3) >> 2; i > 0; --i, dst+=4, src1+=4, src2+=4)
59 {
60 v128_t s1 = wasm_v128_load(src1);
61 v128_t s2 = wasm_v128_load(src2);
62 v128_t d = wasm_v128_load(dst);
63 s1 = wasm_i32x4_shr(wasm_i32x4_add(s1, s2), 1);
64 d = wasm_i32x4_sub(d, s1);
65 wasm_v128_store(dst, d);
66 }
67 }
68
71 const line_buf* line_src2,
72 line_buf *line_dst, ui32 repeat)
73 {
74 si32 *dst = line_dst->i32;
75 const si32 *src1 = line_src1->i32, *src2 = line_src2->i32;
76
77 v128_t offset = wasm_i32x4_splat(2);
78 for (ui32 i = (repeat + 3) >> 2; i > 0; --i, dst+=4, src1+=4, src2+=4)
79 {
80 v128_t s1 = wasm_v128_load(src1);
81 s1 = wasm_i32x4_add(s1, offset);
82 v128_t s2 = wasm_v128_load(src2);
83 s2 = wasm_i32x4_add(s2, s1);
84 v128_t d = wasm_v128_load(dst);
85 d = wasm_i32x4_add(d, wasm_i32x4_shr(s2, 2));
86 wasm_v128_store(dst, d);
87 }
88 }
89
91 void wasm_rev_horz_wvlt_fwd_tx(line_buf *line_src, line_buf *line_ldst,
92 line_buf *line_hdst, ui32 width, bool even)
93 {
94 if (width > 1)
95 {
96 si32 *src = line_src->i32;
97 si32 *ldst = line_ldst->i32, *hdst = line_hdst->i32;
98
99 const ui32 L_width = (width + (even ? 1 : 0)) >> 1;
100 const ui32 H_width = (width + (even ? 0 : 1)) >> 1;
101
102 // extension
103 src[-1] = src[1];
104 src[width] = src[width-2];
105 // predict
106 const si32* sp = src + (even ? 1 : 0);
107 si32 *dph = hdst;
108 for (ui32 i = (H_width + 3) >> 2; i > 0; --i, dph+=4)
109 { //this is doing twice the work it needs to do
110 //it can be definitely written better
111 v128_t s1 = wasm_v128_load(sp - 1);
112 v128_t s2 = wasm_v128_load(sp + 1);
113 v128_t d = wasm_v128_load(sp);
114 s1 = wasm_i32x4_shr(wasm_i32x4_add(s1, s2), 1);
115 v128_t d1 = wasm_i32x4_sub(d, s1);
116 sp += 4;
117 s1 = wasm_v128_load(sp - 1);
118 s2 = wasm_v128_load(sp + 1);
119 d = wasm_v128_load(sp);
120 s1 = wasm_i32x4_shr(wasm_i32x4_add(s1, s2), 1);
121 v128_t d2 = wasm_i32x4_sub(d, s1);
122 sp += 4;
123 d = wasm_i32x4_shuffle(d1, d2, 0, 2, 4, 6);
124 wasm_v128_store(dph, d);
125 }
126
127 // extension
128 hdst[-1] = hdst[0];
129 hdst[H_width] = hdst[H_width-1];
130 // update
131 sp = src + (even ? 0 : 1);
132 const si32* sph = hdst + (even ? 0 : 1);
133 si32 *dpl = ldst;
134 v128_t offset = wasm_i32x4_splat(2);
135 for (ui32 i = (L_width + 3) >> 2; i > 0; --i, sp+=8, sph+=4, dpl+=4)
136 {
137 v128_t s1 = wasm_v128_load(sph - 1);
138 s1 = wasm_i32x4_add(s1, offset);
139 v128_t s2 = wasm_v128_load(sph);
140 s2 = wasm_i32x4_add(s2, s1);
141 v128_t d1 = wasm_v128_load(sp);
142 v128_t d2 = wasm_v128_load(sp + 4);
143 v128_t d = wasm_i32x4_shuffle(d1, d2, 0, 2, 4, 6);
144 d = wasm_i32x4_add(d, wasm_i32x4_shr(s2, 2));
145 wasm_v128_store(dpl, d);
146 }
147 }
148 else
149 {
150 if (even)
151 line_ldst->i32[0] = line_src->i32[0];
152 else
153 line_hdst->i32[0] = line_src->i32[0] << 1;
154 }
155 }
156
159 const line_buf *line_src2,
160 line_buf *line_dst, ui32 repeat)
161 {
162 si32 *dst = line_dst->i32;
163 const si32 *src1 = line_src1->i32, *src2 = line_src2->i32;
164
165 for (ui32 i = (repeat + 3) >> 2; i > 0; --i, dst+=4, src1+=4, src2+=4)
166 {
167 v128_t s1 = wasm_v128_load(src1);
168 v128_t s2 = wasm_v128_load(src2);
169 v128_t d = wasm_v128_load(dst);
170 s1 = wasm_i32x4_shr(wasm_i32x4_add(s1, s2), 1);
171 d = wasm_i32x4_add(d, s1);
172 wasm_v128_store(dst, d);
173 }
174 }
175
178 const line_buf *line_src2,
179 line_buf *line_dst, ui32 repeat)
180 {
181 si32 *dst = line_dst->i32;
182 const si32 *src1 = line_src1->i32, *src2 = line_src2->i32;
183
184 v128_t offset = wasm_i32x4_splat(2);
185 for (ui32 i = (repeat + 3) >> 2; i > 0; --i, dst+=4, src1+=4, src2+=4)
186 {
187 v128_t s1 = wasm_v128_load(src1);
188 s1 = wasm_i32x4_add(s1, offset);
189 v128_t s2 = wasm_v128_load(src2);
190 s2 = wasm_i32x4_add(s2, s1);
191 v128_t d = wasm_v128_load(dst);
192 d = wasm_i32x4_sub(d, wasm_i32x4_shr(s2, 2));
193 wasm_v128_store(dst, d);
194 }
195 }
196
198 void wasm_rev_horz_wvlt_bwd_tx(line_buf *line_dst, line_buf *line_lsrc,
199 line_buf *line_hsrc, ui32 width, bool even)
200 {
201 if (width > 1)
202 {
203 si32 *lsrc = line_lsrc->i32, *hsrc = line_hsrc->i32;
204 si32 *dst = line_dst->i32;
205
206 const ui32 L_width = (width + (even ? 1 : 0)) >> 1;
207 const ui32 H_width = (width + (even ? 0 : 1)) >> 1;
208
209 // extension
210 hsrc[-1] = hsrc[0];
211 hsrc[H_width] = hsrc[H_width-1];
212 //inverse update
213 const si32 *sph = hsrc + (even ? 0 : 1);
214 si32 *spl = lsrc;
215 v128_t offset = wasm_i32x4_splat(2);
216 for (ui32 i = (L_width + 3) >> 2; i > 0; --i, sph+=4, spl+=4)
217 {
218 v128_t s1 = wasm_v128_load(sph - 1);
219 s1 = wasm_i32x4_add(s1, offset);
220 v128_t s2 = wasm_v128_load(sph);
221 s2 = wasm_i32x4_add(s2, s1);
222 v128_t d = wasm_v128_load(spl);
223 d = wasm_i32x4_sub(d, wasm_i32x4_shr(s2, 2));
224 wasm_v128_store(spl, d);
225 }
226
227 // extension
228 lsrc[-1] = lsrc[0];
229 lsrc[L_width] = lsrc[L_width - 1];
230 // inverse predict and combine
231 si32 *dp = dst + (even ? 0 : -1);
232 spl = lsrc + (even ? 0 : -1);
233 sph = hsrc;
234 ui32 width = L_width + (even ? 0 : 1);
235 for (ui32 i = (width + 3) >> 2; i > 0; --i, sph+=4, spl+=4, dp+=8)
236 {
237 v128_t s1 = wasm_v128_load(spl);
238 v128_t s2 = wasm_v128_load(spl + 1);
239 v128_t d = wasm_v128_load(sph);
240 s2 = wasm_i32x4_shr(wasm_i32x4_add(s1, s2), 1);
241 d = wasm_i32x4_add(d, s2);
242 wasm_v128_store(dp, wasm_i32x4_shuffle(s1, d, 0, 4, 1, 5));
243 wasm_v128_store(dp + 4, wasm_i32x4_shuffle(s1, d, 2, 6, 3, 7));
244 }
245 }
246 else
247 {
248 if (even)
249 line_dst->i32[0] = line_lsrc->i32[0];
250 else
251 line_dst->i32[0] = line_hsrc->i32[0] >> 1;
252 }
253 }
254
256 void wasm_irrev_vert_wvlt_step(const line_buf *line_src1,
257 const line_buf *line_src2,
258 line_buf *line_dst, int step_num,
259 ui32 repeat)
260 {
261 float *dst = line_dst->f32;
262 const float *src1 = line_src1->f32, *src2 = line_src2->f32;
263
264 v128_t factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[step_num]);
265 for (ui32 i = (repeat + 3) >> 2; i > 0; --i, dst+=4, src1+=4, src2+=4)
266 {
267 v128_t s1 = wasm_v128_load(src1);
268 v128_t s2 = wasm_v128_load(src2);
269 v128_t d = wasm_v128_load(dst);
270 d = wasm_f32x4_add(d, wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2)));
271 wasm_v128_store(dst, d);
272 }
273 }
274
276 void wasm_irrev_vert_wvlt_K(const line_buf *line_src, line_buf *line_dst,
277 bool L_analysis_or_H_synthesis, ui32 repeat)
278 {
279 float *dst = line_dst->f32;
280 const float *src = line_src->f32;
281
282 float f = LIFTING_FACTORS::K_inv;
283 f = L_analysis_or_H_synthesis ? f : LIFTING_FACTORS::K;
284 v128_t factor = wasm_f32x4_splat(f);
285 for (ui32 i = (repeat + 3) >> 2; i > 0; --i, dst+=4, src+=4)
286 {
287 v128_t s = wasm_v128_load(src);
288 wasm_v128_store(dst, wasm_f32x4_mul(factor, s));
289 }
290 }
291
293 void wasm_irrev_horz_wvlt_fwd_tx(line_buf *line_src, line_buf *line_ldst,
294 line_buf *line_hdst, ui32 width,
295 bool even)
296 {
297 if (width > 1)
298 {
299 float *src = line_src->f32;
300 float *ldst = line_ldst->f32, *hdst = line_hdst->f32;
301
302 const ui32 L_width = (width + (even ? 1 : 0)) >> 1;
303 const ui32 H_width = (width + (even ? 0 : 1)) >> 1;
304
305 //extension
306 src[-1] = src[1];
307 src[width] = src[width-2];
308 // predict
309 const float* sp = src + (even ? 1 : 0);
310 float *dph = hdst;
311 v128_t factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[0]);
312 for (ui32 i = (H_width + 3) >> 2; i > 0; --i, dph+=4)
313 { //this is doing twice the work it needs to do
314 //it can be definitely written better
315 v128_t s1 = wasm_v128_load(sp - 1);
316 v128_t s2 = wasm_v128_load(sp + 1);
317 v128_t d = wasm_v128_load(sp);
318 s1 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
319 v128_t d1 = wasm_f32x4_add(d, s1);
320 sp += 4;
321 s1 = wasm_v128_load(sp - 1);
322 s2 = wasm_v128_load(sp + 1);
323 d = wasm_v128_load(sp);
324 s1 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
325 v128_t d2 = wasm_f32x4_add(d, s1);
326 sp += 4;
327 d = wasm_i32x4_shuffle(d1, d2, 0, 2, 4, 6);
328 wasm_v128_store(dph, d);
329 }
330
331 // extension
332 hdst[-1] = hdst[0];
333 hdst[H_width] = hdst[H_width-1];
334 // update
335 factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[1]);
336 sp = src + (even ? 0 : 1);
337 const float* sph = hdst + (even ? 0 : 1);
338 float *dpl = ldst;
339 for (ui32 i = (L_width + 3) >> 2; i > 0; --i, sp+=8, sph+=4, dpl+=4)
340 {
341 v128_t s1 = wasm_v128_load(sph - 1);
342 v128_t s2 = wasm_v128_load(sph);
343 s1 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
344 v128_t d1 = wasm_v128_load(sp);
345 v128_t d2 = wasm_v128_load(sp + 4);
346 v128_t d = wasm_i32x4_shuffle(d1, d2, 0, 2, 4, 6);
347 d = wasm_f32x4_add(d, s1);
348 wasm_v128_store(dpl, d);
349 }
350
351 //extension
352 ldst[-1] = ldst[0];
353 ldst[L_width] = ldst[L_width-1];
354 //predict
355 factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[2]);
356 const float* spl = ldst + (even ? 1 : 0);
357 dph = hdst;
358 for (ui32 i = (H_width + 3) >> 2; i > 0; --i, spl+=4, dph+=4)
359 {
360 v128_t s1 = wasm_v128_load(spl - 1);
361 v128_t s2 = wasm_v128_load(spl);
362 v128_t d = wasm_v128_load(dph);
363 s1 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
364 d = wasm_f32x4_add(d, s1);
365 wasm_v128_store(dph, d);
366 }
367
368 // extension
369 hdst[-1] = hdst[0];
370 hdst[H_width] = hdst[H_width-1];
371 // update
372 factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[3]);
373 sph = hdst + (even ? 0 : 1);
374 dpl = ldst;
375 for (ui32 i = (L_width + 3) >> 2; i > 0; --i, sph+=4, dpl+=4)
376 {
377 v128_t s1 = wasm_v128_load(sph - 1);
378 v128_t s2 = wasm_v128_load(sph);
379 v128_t d = wasm_v128_load(dpl);
380 s1 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
381 d = wasm_f32x4_add(d, s1);
382 wasm_v128_store(dpl, d);
383 }
384
385 //multipliers
386 float *dp = ldst;
387 factor = wasm_f32x4_splat(LIFTING_FACTORS::K_inv);
388 for (ui32 i = (L_width + 3) >> 2; i > 0; --i, dp+=4)
389 {
390 v128_t d = wasm_v128_load(dp);
391 wasm_v128_store(dp, wasm_f32x4_mul(factor, d));
392 }
393 dp = hdst;
394 factor = wasm_f32x4_splat(LIFTING_FACTORS::K);
395 for (int i = (H_width + 3) >> 2; i > 0; --i, dp+=4)
396 {
397 v128_t d = wasm_v128_load(dp);
398 wasm_v128_store(dp, wasm_f32x4_mul(factor, d));
399 }
400 }
401 else
402 {
403 if (even)
404 line_ldst->f32[0] = line_src->f32[0];
405 else
406 line_hdst->f32[0] = line_src->f32[0] + line_src->f32[0];
407 }
408 }
409
411 void wasm_irrev_horz_wvlt_bwd_tx(line_buf *line_dst, line_buf *line_lsrc,
412 line_buf *line_hsrc, ui32 width,
413 bool even)
414 {
415 if (width > 1)
416 {
417 float *lsrc = line_lsrc->f32, *hsrc = line_hsrc->f32;
418 float *dst = line_dst->f32;
419
420 const ui32 L_width = (width + (even ? 1 : 0)) >> 1;
421 const ui32 H_width = (width + (even ? 0 : 1)) >> 1;
422
423 //multipliers
424 float *dp = lsrc;
425 v128_t factor = wasm_f32x4_splat(LIFTING_FACTORS::K);
426 for (ui32 i = (L_width + 3) >> 2; i > 0; --i, dp+=4)
427 {
428 v128_t d = wasm_v128_load(dp);
429 wasm_v128_store(dp, wasm_f32x4_mul(factor, d));
430 }
431 dp = hsrc;
432 factor = wasm_f32x4_splat(LIFTING_FACTORS::K_inv);
433 for (ui32 i = (H_width + 3) >> 2; i > 0; --i, dp+=4)
434 {
435 v128_t d = wasm_v128_load(dp);
436 wasm_v128_store(dp, wasm_f32x4_mul(factor, d));
437 }
438
439 //extension
440 hsrc[-1] = hsrc[0];
441 hsrc[H_width] = hsrc[H_width-1];
442 //inverse update
443 factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[7]);
444 const float *sph = hsrc + (even ? 0 : 1);
445 float *dpl = lsrc;
446 for (ui32 i = (L_width + 3) >> 2; i > 0; --i, dpl+=4, sph+=4)
447 {
448 v128_t s1 = wasm_v128_load(sph - 1);
449 v128_t s2 = wasm_v128_load(sph);
450 v128_t d = wasm_v128_load(dpl);
451 s1 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
452 d = wasm_f32x4_add(d, s1);
453 wasm_v128_store(dpl, d);
454 }
455
456 //extension
457 lsrc[-1] = lsrc[0];
458 lsrc[L_width] = lsrc[L_width-1];
459 //inverse perdict
460 factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[6]);
461 const float *spl = lsrc + (even ? 0 : -1);
462 float *dph = hsrc;
463 for (ui32 i = (H_width + 3) >> 2; i > 0; --i, dph+=4, spl+=4)
464 {
465 v128_t s1 = wasm_v128_load(spl);
466 v128_t s2 = wasm_v128_load(spl + 1);
467 v128_t d = wasm_v128_load(dph);
468 s1 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
469 d = wasm_f32x4_add(d, s1);
470 wasm_v128_store(dph, d);
471 }
472
473 //extension
474 hsrc[-1] = hsrc[0];
475 hsrc[H_width] = hsrc[H_width-1];
476 //inverse update
477 factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[5]);
478 sph = hsrc + (even ? 0 : 1);
479 dpl = lsrc;
480 for (ui32 i = (L_width + 3) >> 2; i > 0; --i, dpl+=4, sph+=4)
481 {
482 v128_t s1 = wasm_v128_load(sph - 1);
483 v128_t s2 = wasm_v128_load(sph);
484 v128_t d = wasm_v128_load(dpl);
485 s1 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
486 d = wasm_f32x4_add(d, s1);
487 wasm_v128_store(dpl, d);
488 }
489
490 //extension
491 lsrc[-1] = lsrc[0];
492 lsrc[L_width] = lsrc[L_width-1];
493 //inverse perdict and combine
494 factor = wasm_f32x4_splat(LIFTING_FACTORS::steps[4]);
495 dp = dst + (even ? 0 : -1);
496 spl = lsrc + (even ? 0 : -1);
497 sph = hsrc;
498 ui32 width = L_width + (even ? 0 : 1);
499 for (ui32 i = (width + 3) >> 2; i > 0; --i, spl+=4, sph+=4, dp+=8)
500 {
501 v128_t s1 = wasm_v128_load(spl);
502 v128_t s2 = wasm_v128_load(spl + 1);
503 v128_t d = wasm_v128_load(sph);
504 s2 = wasm_f32x4_mul(factor, wasm_f32x4_add(s1, s2));
505 d = wasm_f32x4_add(d, s2);
506 wasm_v128_store(dp, wasm_i32x4_shuffle(s1, d, 0, 4, 1, 5));
507 wasm_v128_store(dp + 4, wasm_i32x4_shuffle(s1, d, 2, 6, 3, 7));
508 }
509 }
510 else
511 {
512 if (even)
513 line_dst->f32[0] = line_lsrc->f32[0];
514 else
515 line_dst->f32[0] = line_hsrc->f32[0] * 0.5f;
516 }
517 }
518
519 }
520}
void wasm_rev_horz_wvlt_bwd_tx(line_buf *line_dst, line_buf *line_lsrc, line_buf *line_hsrc, ui32 width, bool even)
void wasm_rev_vert_wvlt_fwd_update(const line_buf *line_src1, const line_buf *line_src2, line_buf *line_dst, ui32 repeat)
void wasm_rev_vert_wvlt_bwd_predict(const line_buf *line_src1, const line_buf *line_src2, line_buf *line_dst, ui32 repeat)
void wasm_irrev_horz_wvlt_bwd_tx(line_buf *line_src, line_buf *line_ldst, line_buf *line_hdst, ui32 width, bool even)
void wasm_irrev_vert_wvlt_K(const line_buf *line_src, line_buf *line_dst, bool L_analysis_or_H_synthesis, ui32 repeat)
void wasm_irrev_vert_wvlt_step(const line_buf *line_src1, const line_buf *line_src2, line_buf *line_dst, int step_num, ui32 repeat)
void wasm_rev_horz_wvlt_fwd_tx(line_buf *line_src, line_buf *line_ldst, line_buf *line_hdst, ui32 width, bool even)
void wasm_irrev_horz_wvlt_fwd_tx(line_buf *line_src, line_buf *line_ldst, line_buf *line_hdst, ui32 width, bool even)
void wasm_rev_vert_wvlt_fwd_predict(const line_buf *line_src1, const line_buf *line_src2, line_buf *line_dst, ui32 repeat)
void wasm_rev_vert_wvlt_bwd_update(const line_buf *line_src1, const line_buf *line_src2, line_buf *line_dst, ui32 repeat)
int32_t si32
Definition: ojph_defs.h:55
uint32_t ui32
Definition: ojph_defs.h:54
float * f32
Definition: ojph_mem.h:156
si32 * i32
Definition: ojph_mem.h:155