CoCalc -- u_format

GitHub Repository: PojavLauncherTeam/mesa
Path: blob/21.2-virgl/src/util/format/u_format_rgtc.c
⁷²³³ views
1
/**************************************************************************
2
 *
3
 * Copyright (C) 2011 Red Hat Inc.
4
 *
5
 * Permission is hereby granted, free of charge, to any person obtaining a
6
 * copy of this software and associated documentation files (the "Software"),
7
 * to deal in the Software without restriction, including without limitation
8
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9
 * and/or sell copies of the Software, and to permit persons to whom the
10
 * Software is furnished to do so, subject to the following conditions:
11
 *
12
 * The above copyright notice and this permission notice shall be included
13
 * in all copies or substantial portions of the Software.
14
 *
15
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21
 * OTHER DEALINGS IN THE SOFTWARE.
22
 *
23
 **************************************************************************/
24

25
#include <stdio.h>
26
#include "util/format/u_format.h"
27
#include "util/format/u_format_rgtc.h"
28
#include "util/u_math.h"
29
#include "util/rgtc.h"
30

31
void
32
util_format_rgtc1_unorm_fetch_rgba_8unorm(uint8_t *restrict dst, const uint8_t *restrict src, unsigned i, unsigned j)
33
{
34
   util_format_unsigned_fetch_texel_rgtc(0, src, i, j, dst, 1);
35
   dst[1] = 0;
36
   dst[2] = 0;
37
   dst[3] = 255;
38
}
39

40
void
41
util_format_rgtc1_unorm_unpack_rgba_8unorm(uint8_t *restrict dst_row, unsigned dst_stride, const uint8_t *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
42
{
43
   const unsigned bw = 4, bh = 4, comps = 4;
44
   unsigned x, y, i, j;
45
   unsigned block_size = 8;
46

47
   for(y = 0; y < height; y += bh) {
48
      const uint8_t *src = src_row;
49
      for(x = 0; x < width; x += bw) {
50
         for(j = 0; j < bh; ++j) {
51
            for(i = 0; i < bw; ++i) {
52
               uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*comps;
53
	       util_format_unsigned_fetch_texel_rgtc(0, src, i, j, dst, 1);
54
	       dst[1] = 0;
55
	       dst[2] = 0;
56
	       dst[3] = 255;
57
	    }
58
	 }
59
	 src += block_size;
60
      }
61
      src_row += src_stride;
62
   }
63
}
64

65
void
66
util_format_rgtc1_unorm_pack_rgba_8unorm(uint8_t *restrict dst_row, unsigned dst_stride, const uint8_t *restrict src_row, 
67
					 unsigned src_stride, unsigned width, unsigned height)
68
{
69
   const unsigned bw = 4, bh = 4, bytes_per_block = 8;
70
   unsigned x, y, i, j;
71

72
   for(y = 0; y < height; y += bh) {
73
      uint8_t *dst = dst_row;
74
      for(x = 0; x < width; x += bw) {
75
         uint8_t tmp[4][4];  /* [bh][bw][comps] */
76
         for(j = 0; j < bh; ++j) {
77
            for(i = 0; i < bw; ++i) {
78
	       tmp[j][i] = src_row[(y + j)*src_stride/sizeof(*src_row) + (x + i)*4];
79
            }
80
         }
81
         util_format_unsigned_encode_rgtc_ubyte(dst, tmp, 4, 4);
82
         dst += bytes_per_block;
83
      }
84
      dst_row += dst_stride / sizeof(*dst_row);
85
   }
86
}
87

88
void
89
util_format_rgtc1_unorm_unpack_rgba_float(void *restrict dst_row, unsigned dst_stride, const uint8_t *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
90
{
91
   unsigned x, y, i, j;
92
   int block_size = 8;
93
   for(y = 0; y < height; y += 4) {
94
      const uint8_t *src = src_row;
95
      for(x = 0; x < width; x += 4) {
96
         for(j = 0; j < 4; ++j) {
97
            for(i = 0; i < 4; ++i) {
98
               float *dst = (float *)((uint8_t *)dst_row + (y + j)*dst_stride + (x + i)*16);
99
               uint8_t tmp_r;
100
               util_format_unsigned_fetch_texel_rgtc(0, src, i, j, &tmp_r, 1);
101
               dst[0] = ubyte_to_float(tmp_r);
102
               dst[1] = 0.0;
103
               dst[2] = 0.0;
104
               dst[3] = 1.0;
105
            }
106
         }
107
         src += block_size;
108
      }
109
      src_row += src_stride;
110
   }
111
}
112

113
void
114
util_format_rgtc1_unorm_pack_rgba_float(uint8_t *restrict dst_row, unsigned dst_stride, const float *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
115
{
116
   const unsigned bw = 4, bh = 4, bytes_per_block = 8;
117
   unsigned x, y, i, j;
118

119
   for(y = 0; y < height; y += bh) {
120
      uint8_t *dst = dst_row;
121
      for(x = 0; x < width; x += bw) {
122
         uint8_t tmp[4][4];  /* [bh][bw][comps] */
123
         for(j = 0; j < bh; ++j) {
124
            for(i = 0; i < bw; ++i) {
125
	       tmp[j][i] = float_to_ubyte(src_row[(y + j)*src_stride/sizeof(*src_row) + (x + i)*4]);
126
            }
127
         }
128
         util_format_unsigned_encode_rgtc_ubyte(dst, tmp, 4, 4);
129
         dst += bytes_per_block;
130
      }
131
      dst_row += dst_stride / sizeof(*dst_row);
132
   }
133
}
134

135
void
136
util_format_rgtc1_unorm_fetch_rgba(void *restrict in_dst, const uint8_t *restrict src, unsigned i, unsigned j)
137
{
138
   float *dst = in_dst;
139
   uint8_t tmp_r;
140
   util_format_unsigned_fetch_texel_rgtc(0, src, i, j, &tmp_r, 1);
141
   dst[0] = ubyte_to_float(tmp_r);
142
   dst[1] = 0.0;
143
   dst[2] = 0.0;
144
   dst[3] = 1.0;
145
}
146

147
void
148
util_format_rgtc1_snorm_fetch_rgba_8unorm(UNUSED uint8_t *restrict dst, UNUSED const uint8_t *restrict src,
149
                                          UNUSED unsigned i, UNUSED unsigned j)
150
{
151
   fprintf(stderr,"%s\n", __func__);
152
}
153

154
void
155
util_format_rgtc1_snorm_unpack_rgba_8unorm(UNUSED uint8_t *restrict dst_row, UNUSED unsigned dst_stride,
156
                                           UNUSED const uint8_t *restrict src_row, UNUSED unsigned src_stride,
157
                                           UNUSED unsigned width, UNUSED unsigned height)
158
{
159
   fprintf(stderr,"%s\n", __func__);
160
}
161

162
void
163
util_format_rgtc1_snorm_pack_rgba_8unorm(UNUSED uint8_t *restrict dst_row, UNUSED unsigned dst_stride,
164
                                         UNUSED const uint8_t *restrict src_row, UNUSED unsigned src_stride,
165
                                         UNUSED unsigned width, UNUSED unsigned height)
166
{
167
   fprintf(stderr,"%s\n", __func__);
168
}
169

170
void
171
util_format_rgtc1_snorm_pack_rgba_float(uint8_t *restrict dst_row, unsigned dst_stride, const float *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
172
{
173
   const unsigned bw = 4, bh = 4, bytes_per_block = 8;
174
   unsigned x, y, i, j;
175

176
   for(y = 0; y < height; y += bh) {
177
      int8_t *dst = (int8_t *)dst_row;
178
      for(x = 0; x < width; x += bw) {
179
         int8_t tmp[4][4];  /* [bh][bw][comps] */
180
         for(j = 0; j < bh; ++j) {
181
            for(i = 0; i < bw; ++i) {
182
	       tmp[j][i] = float_to_byte_tex(src_row[(y + j)*src_stride/sizeof(*src_row) + (x + i)*4]);
183
            }
184
         }
185
         util_format_signed_encode_rgtc_ubyte(dst, tmp, 4, 4);
186
         dst += bytes_per_block;
187
      }
188
      dst_row += dst_stride / sizeof(*dst_row);
189
   }
190
}
191

192
void
193
util_format_rgtc1_snorm_unpack_rgba_float(void *restrict dst_row, unsigned dst_stride, const uint8_t *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
194
{
195
   unsigned x, y, i, j;
196
   int block_size = 8;
197
   for(y = 0; y < height; y += 4) {
198
      const int8_t *src = (int8_t *)src_row;
199
      for(x = 0; x < width; x += 4) {
200
         for(j = 0; j < 4; ++j) {
201
            for(i = 0; i < 4; ++i) {
202
               float *dst = (float *)((uint8_t *)dst_row + (y + j)*dst_stride + (x + i)*16);
203
               int8_t tmp_r;
204
               util_format_signed_fetch_texel_rgtc(0, src, i, j, &tmp_r, 1);
205
               dst[0] = byte_to_float_tex(tmp_r);
206
               dst[1] = 0.0;
207
               dst[2] = 0.0;
208
               dst[3] = 1.0;
209
            }
210
         }
211
         src += block_size;
212
      }
213
      src_row += src_stride;
214
   }
215
}
216

217
void
218
util_format_rgtc1_snorm_fetch_rgba(void *restrict in_dst, const uint8_t *restrict src, unsigned i, unsigned j)
219
{
220
   float *dst = in_dst;
221
   int8_t tmp_r;
222
   util_format_signed_fetch_texel_rgtc(0, (int8_t *)src, i, j, &tmp_r, 1);
223
   dst[0] = byte_to_float_tex(tmp_r);
224
   dst[1] = 0.0;
225
   dst[2] = 0.0;
226
   dst[3] = 1.0;
227
}
228

229

230
void
231
util_format_rgtc2_unorm_fetch_rgba_8unorm(uint8_t *restrict dst, const uint8_t *restrict src, unsigned i, unsigned j)
232
{
233
   util_format_unsigned_fetch_texel_rgtc(0, src, i, j, dst, 2);
234
   util_format_unsigned_fetch_texel_rgtc(0, src + 8, i, j, dst + 1, 2);
235
   dst[2] = 0;
236
   dst[3] = 255;
237
}
238

239
void
240
util_format_rgtc2_unorm_unpack_rgba_8unorm(uint8_t *restrict dst_row, unsigned dst_stride, const uint8_t *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
241
{
242
   const unsigned bw = 4, bh = 4, comps = 4;
243
   unsigned x, y, i, j;
244
   unsigned block_size = 16;
245

246
   for(y = 0; y < height; y += bh) {
247
      const uint8_t *src = src_row;
248
      for(x = 0; x < width; x += bw) {
249
         for(j = 0; j < bh; ++j) {
250
            for(i = 0; i < bw; ++i) {
251
               uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*comps;
252
	       util_format_unsigned_fetch_texel_rgtc(0, src, i, j, dst, 2);
253
	       util_format_unsigned_fetch_texel_rgtc(0, src + 8, i, j, dst + 1, 2);
254
	       dst[2] = 0;
255
	       dst[3] = 255;
256
	    }
257
	 }
258
	 src += block_size;
259
      }
260
      src_row += src_stride;
261
   }
262
}
263

264
void
265
util_format_rgtc2_unorm_pack_rgba_8unorm(uint8_t *restrict dst_row, unsigned dst_stride, const uint8_t *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
266
{
267
   const unsigned bw = 4, bh = 4, bytes_per_block = 16;
268
   unsigned x, y, i, j;
269

270
   for(y = 0; y < height; y += bh) {
271
      uint8_t *dst = dst_row;
272
      for(x = 0; x < width; x += bw) {
273
         uint8_t tmp_r[4][4];  /* [bh][bw] */
274
         uint8_t tmp_g[4][4];  /* [bh][bw] */
275
         for(j = 0; j < bh; ++j) {
276
            for(i = 0; i < bw; ++i) {
277
	       tmp_r[j][i] = src_row[(y + j)*src_stride/sizeof(*src_row) + (x + i)*4];
278
	       tmp_g[j][i] = src_row[((y + j)*src_stride/sizeof(*src_row) + (x + i)*4) + 1];
279
            }
280
         }
281
         util_format_unsigned_encode_rgtc_ubyte(dst, tmp_r, 4, 4);
282
         util_format_unsigned_encode_rgtc_ubyte(dst + 8, tmp_g, 4, 4);
283
         dst += bytes_per_block;
284
      }
285
      dst_row += dst_stride / sizeof(*dst_row);
286
   }
287
}
288

289
void
290
util_format_rxtc2_unorm_pack_rgba_float(uint8_t *restrict dst_row, unsigned dst_stride, const float *restrict src_row, unsigned src_stride, unsigned width, unsigned height, unsigned chan2off)
291
{
292
   const unsigned bw = 4, bh = 4, bytes_per_block = 16;
293
   unsigned x, y, i, j;
294

295
   for(y = 0; y < height; y += bh) {
296
      uint8_t *dst = dst_row;
297
      for(x = 0; x < width; x += bw) {
298
         uint8_t tmp_r[4][4];  /* [bh][bw][comps] */
299
         uint8_t tmp_g[4][4];  /* [bh][bw][comps] */
300
         for(j = 0; j < bh; ++j) {
301
            for(i = 0; i < bw; ++i) {
302
	       tmp_r[j][i] = float_to_ubyte(src_row[(y + j)*src_stride/sizeof(*src_row) + (x + i)*4]);
303
               tmp_g[j][i] = float_to_ubyte(src_row[(y + j)*src_stride/sizeof(*src_row) + (x + i)*4 + chan2off]);
304
            }
305
         }
306
         util_format_unsigned_encode_rgtc_ubyte(dst, tmp_r, 4, 4);
307
         util_format_unsigned_encode_rgtc_ubyte(dst + 8, tmp_g, 4, 4);
308
         dst += bytes_per_block;
309
      }
310
      dst_row += dst_stride / sizeof(*dst_row);
311
   }
312
}
313

314
void
315
util_format_rgtc2_unorm_pack_rgba_float(uint8_t *restrict dst_row, unsigned dst_stride, const float *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
316
{
317
   util_format_rxtc2_unorm_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height, 1);
318
}
319

320
void
321
util_format_rgtc2_unorm_unpack_rgba_float(void *restrict dst_row, unsigned dst_stride, const uint8_t *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
322
{
323
   unsigned x, y, i, j;
324
   int block_size = 16;
325
   for(y = 0; y < height; y += 4) {
326
      const uint8_t *src = src_row;
327
      for(x = 0; x < width; x += 4) {
328
         for(j = 0; j < 4; ++j) {
329
            for(i = 0; i < 4; ++i) {
330
               float *dst = (float *)((uint8_t *)dst_row + (y + j)*dst_stride + (x + i)*16);
331
               uint8_t tmp_r, tmp_g;
332
               util_format_unsigned_fetch_texel_rgtc(0, src, i, j, &tmp_r, 2);
333
               util_format_unsigned_fetch_texel_rgtc(0, src + 8, i, j, &tmp_g, 2);
334
               dst[0] = ubyte_to_float(tmp_r);
335
               dst[1] = ubyte_to_float(tmp_g);
336
               dst[2] = 0.0;
337
               dst[3] = 1.0;
338
            }
339
         }
340
         src += block_size;
341
      }
342
      src_row += src_stride;
343
   }
344
}
345

346
void
347
util_format_rgtc2_unorm_fetch_rgba(void *restrict in_dst, const uint8_t *restrict src, unsigned i, unsigned j)
348
{
349
   float *dst = in_dst;
350
   uint8_t tmp_r, tmp_g;
351
   util_format_unsigned_fetch_texel_rgtc(0, src, i, j, &tmp_r, 2);
352
   util_format_unsigned_fetch_texel_rgtc(0, src + 8, i, j, &tmp_g, 2);
353
   dst[0] = ubyte_to_float(tmp_r);
354
   dst[1] = ubyte_to_float(tmp_g);
355
   dst[2] = 0.0;
356
   dst[3] = 1.0;
357
}
358

359

360
void
361
util_format_rgtc2_snorm_fetch_rgba_8unorm(UNUSED uint8_t *restrict dst, UNUSED const uint8_t *restrict src,
362
                                          UNUSED unsigned i, UNUSED unsigned j)
363
{
364
   fprintf(stderr,"%s\n", __func__);
365
}
366

367
void
368
util_format_rgtc2_snorm_unpack_rgba_8unorm(UNUSED uint8_t *restrict dst_row, UNUSED unsigned dst_stride,
369
                                           UNUSED const uint8_t *restrict src_row, UNUSED unsigned src_stride,
370
                                           UNUSED unsigned width, UNUSED unsigned height)
371
{
372
   fprintf(stderr,"%s\n", __func__);
373
}
374

375
void
376
util_format_rgtc2_snorm_pack_rgba_8unorm(UNUSED uint8_t *restrict dst_row, UNUSED unsigned dst_stride,
377
                                         UNUSED const uint8_t *restrict src_row, UNUSED unsigned src_stride,
378
                                         UNUSED unsigned width, UNUSED unsigned height)
379
{
380
   fprintf(stderr,"%s\n", __func__);
381
}
382

383
void
384
util_format_rgtc2_snorm_unpack_rgba_float(void *restrict dst_row, unsigned dst_stride, const uint8_t *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
385
{
386
   unsigned x, y, i, j;
387
   int block_size = 16;
388
   for(y = 0; y < height; y += 4) {
389
      const int8_t *src = (int8_t *)src_row;
390
      for(x = 0; x < width; x += 4) {
391
         for(j = 0; j < 4; ++j) {
392
            for(i = 0; i < 4; ++i) {
393
               float *dst = (float *)((uint8_t *)dst_row + (y + j)*dst_stride + (x + i)*16);
394
               int8_t tmp_r, tmp_g;
395
               util_format_signed_fetch_texel_rgtc(0, src, i, j, &tmp_r, 2);
396
               util_format_signed_fetch_texel_rgtc(0, src + 8, i, j, &tmp_g, 2);
397
               dst[0] = byte_to_float_tex(tmp_r);
398
               dst[1] = byte_to_float_tex(tmp_g);
399
               dst[2] = 0.0;
400
               dst[3] = 1.0;
401
            }
402
         }
403
         src += block_size;
404
      }
405
      src_row += src_stride;
406
   }
407
}
408

409
void
410
util_format_rxtc2_snorm_pack_rgba_float(uint8_t *restrict dst_row, unsigned dst_stride, const float *restrict src_row, unsigned src_stride, unsigned width, unsigned height, unsigned chan2off)
411
{
412
   const unsigned bw = 4, bh = 4, bytes_per_block = 16;
413
   unsigned x, y, i, j;
414

415
   for(y = 0; y < height; y += bh) {
416
      int8_t *dst = (int8_t *)dst_row;
417
      for(x = 0; x < width; x += bw) {
418
         int8_t tmp_r[4][4];  /* [bh][bw][comps] */
419
         int8_t tmp_g[4][4];  /* [bh][bw][comps] */
420
         for(j = 0; j < bh; ++j) {
421
            for(i = 0; i < bw; ++i) {
422
	       tmp_r[j][i] = float_to_byte_tex(src_row[(y + j)*src_stride/sizeof(*src_row) + (x + i)*4]);
423
               tmp_g[j][i] = float_to_byte_tex(src_row[(y + j)*src_stride/sizeof(*src_row) + (x + i)*4 + chan2off]);
424
            }
425
         }
426
         util_format_signed_encode_rgtc_ubyte(dst, tmp_r, 4, 4);
427
         util_format_signed_encode_rgtc_ubyte(dst + 8, tmp_g, 4, 4);
428
         dst += bytes_per_block;
429
      }
430
      dst_row += dst_stride / sizeof(*dst_row);
431
   }
432
}
433

434
void
435
util_format_rgtc2_snorm_pack_rgba_float(uint8_t *restrict dst_row, unsigned dst_stride, const float *restrict src_row, unsigned src_stride, unsigned width, unsigned height)
436
{
437
   util_format_rxtc2_snorm_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height, 1);
438
}
439

440
void
441
util_format_rgtc2_snorm_fetch_rgba(void *restrict in_dst, const uint8_t *restrict src, unsigned i, unsigned j)
442
{
443
   float *dst = in_dst;
444
   int8_t tmp_r, tmp_g;
445
   util_format_signed_fetch_texel_rgtc(0, (int8_t *)src, i, j, &tmp_r, 2);
446
   util_format_signed_fetch_texel_rgtc(0, (int8_t *)src + 8, i, j, &tmp_g, 2);
447
   dst[0] = byte_to_float_tex(tmp_r);
448
   dst[1] = byte_to_float_tex(tmp_g);
449
   dst[2] = 0.0;
450
   dst[3] = 1.0;
451
}
452

453

454
Product

Resources

Company
