← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/util/u_format_yuv.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/auxiliary/util/u_format_yuv.c
 
1
/**************************************************************************
 
2
 *
 
3
 * Copyright 2010 VMware, Inc.
 
4
 * All Rights Reserved.
 
5
 *
 
6
 * Permission is hereby granted, free of charge, to any person obtaining a
 
7
 * copy of this software and associated documentation files (the
 
8
 * "Software"), to deal in the Software without restriction, including
 
9
 * without limitation the rights to use, copy, modify, merge, publish,
 
10
 * distribute, sub license, and/or sell copies of the Software, and to
 
11
 * permit persons to whom the Software is furnished to do so, subject to
 
12
 * the following conditions:
 
13
 *
 
14
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
15
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
16
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 
17
 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
 
18
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 
19
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 
20
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 
21
 *
 
22
 * The above copyright notice and this permission notice (including the
 
23
 * next paragraph) shall be included in all copies or substantial portions
 
24
 * of the Software.
 
25
 *
 
26
 **************************************************************************/
 
27
 
 
28
 
 
29
/**
 
30
 * @file
 
31
 * YUV and RGB subsampled formats conversion.
 
32
 *
 
33
 * @author Jose Fonseca <jfonseca@vmware.com>
 
34
 */
 
35
 
 
36
 
 
37
#include "util/u_format_yuv.h"
 
38
 
 
39
 
 
40
void
 
41
util_format_r8g8_b8g8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 
42
                                         const uint8_t *src_row, unsigned src_stride,
 
43
                                         unsigned width, unsigned height)
 
44
{
 
45
   unsigned x, y;
 
46
 
 
47
   for (y = 0; y < height; y += 1) {
 
48
      float *dst = dst_row;
 
49
      const uint32_t *src = (const uint32_t *)src_row;
 
50
      uint32_t value;
 
51
      float r, g0, g1, b;
 
52
 
 
53
      for (x = 0; x + 1 < width; x += 2) {
 
54
         value = *src++;
 
55
 
 
56
#ifdef PIPE_ARCH_BIG_ENDIAN
 
57
         value = util_bswap32(value);
 
58
#endif
 
59
 
 
60
         r  = ubyte_to_float((value >>  0) & 0xff);
 
61
         g0 = ubyte_to_float((value >>  8) & 0xff);
 
62
         b  = ubyte_to_float((value >> 16) & 0xff);
 
63
         g1 = ubyte_to_float((value >> 24) & 0xff);
 
64
 
 
65
         dst[0] = r;    /* r */
 
66
         dst[1] = g0;   /* g */
 
67
         dst[2] = b;    /* b */
 
68
         dst[3] = 1.0f; /* a */
 
69
         dst += 4;
 
70
 
 
71
         dst[0] = r;    /* r */
 
72
         dst[1] = g1;   /* g */
 
73
         dst[2] = b;    /* b */
 
74
         dst[3] = 1.0f; /* a */
 
75
         dst += 4;
 
76
      }
 
77
 
 
78
      if (x < width) {
 
79
         value = *src;
 
80
 
 
81
#ifdef PIPE_ARCH_BIG_ENDIAN
 
82
         value = util_bswap32(value);
 
83
#endif
 
84
 
 
85
         r  = ubyte_to_float((value >>  0) & 0xff);
 
86
         g0 = ubyte_to_float((value >>  8) & 0xff);
 
87
         b  = ubyte_to_float((value >> 16) & 0xff);
 
88
         g1 = ubyte_to_float((value >> 24) & 0xff);
 
89
 
 
90
         dst[0] = r;    /* r */
 
91
         dst[1] = g0;   /* g */
 
92
         dst[2] = b;    /* b */
 
93
         dst[3] = 1.0f; /* a */
 
94
      }
 
95
 
 
96
      src_row += src_stride/sizeof(*src_row);
 
97
      dst_row += dst_stride/sizeof(*dst_row);
 
98
   }
 
99
}
 
100
 
 
101
 
 
102
void
 
103
util_format_r8g8_b8g8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 
104
                                          const uint8_t *src_row, unsigned src_stride,
 
105
                                          unsigned width, unsigned height)
 
106
{
 
107
   unsigned x, y;
 
108
 
 
109
   for (y = 0; y < height; y += 1) {
 
110
      uint8_t *dst = dst_row;
 
111
      const uint32_t *src = (const uint32_t *)src_row;
 
112
      uint32_t value;
 
113
      uint8_t r, g0, g1, b;
 
114
 
 
115
      for (x = 0; x + 1 < width; x += 2) {
 
116
         value = *src++;
 
117
 
 
118
#ifdef PIPE_ARCH_BIG_ENDIAN
 
119
         value = util_bswap32(value);
 
120
#endif
 
121
 
 
122
         r  = (value >>  0) & 0xff;
 
123
         g0 = (value >>  8) & 0xff;
 
124
         b  = (value >> 16) & 0xff;
 
125
         g1 = (value >> 24) & 0xff;
 
126
 
 
127
         dst[0] = r;    /* r */
 
128
         dst[1] = g0;   /* g */
 
129
         dst[2] = b;    /* b */
 
130
         dst[3] = 0xff; /* a */
 
131
         dst += 4;
 
132
 
 
133
         dst[0] = r;    /* r */
 
134
         dst[1] = g1;   /* g */
 
135
         dst[2] = b;    /* b */
 
136
         dst[3] = 0xff; /* a */
 
137
         dst += 4;
 
138
      }
 
139
 
 
140
      if (x < width) {
 
141
         value = *src;
 
142
 
 
143
#ifdef PIPE_ARCH_BIG_ENDIAN
 
144
         value = util_bswap32(value);
 
145
#endif
 
146
 
 
147
         r  = (value >>  0) & 0xff;
 
148
         g0 = (value >>  8) & 0xff;
 
149
         b  = (value >> 16) & 0xff;
 
150
         g1 = (value >> 24) & 0xff;
 
151
 
 
152
         dst[0] = r;    /* r */
 
153
         dst[1] = g0;   /* g */
 
154
         dst[2] = b;    /* b */
 
155
         dst[3] = 0xff; /* a */
 
156
      }
 
157
 
 
158
      src_row += src_stride/sizeof(*src_row);
 
159
      dst_row += dst_stride/sizeof(*dst_row);
 
160
   }
 
161
}
 
162
 
 
163
 
 
164
void
 
165
util_format_r8g8_b8g8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
 
166
                                       const float *src_row, unsigned src_stride,
 
167
                                       unsigned width, unsigned height)
 
168
{
 
169
   unsigned x, y;
 
170
 
 
171
   for (y = 0; y < height; y += 1) {
 
172
      const float *src = src_row;
 
173
      uint32_t *dst = (uint32_t *)dst_row;
 
174
      float r, g0, g1, b;
 
175
      uint32_t value;
 
176
 
 
177
      for (x = 0; x + 1 < width; x += 2) {
 
178
         r  = 0.5f*(src[0] + src[4]);
 
179
         g0 = src[1];
 
180
         g1 = src[5];
 
181
         b  = 0.5f*(src[2] + src[6]);
 
182
 
 
183
         value  = float_to_ubyte(r);
 
184
         value |= float_to_ubyte(g0) <<  8;
 
185
         value |= float_to_ubyte(b)  << 16;
 
186
         value |= float_to_ubyte(g1) << 24;
 
187
 
 
188
#ifdef PIPE_ARCH_BIG_ENDIAN
 
189
         value = util_bswap32(value);
 
190
#endif
 
191
 
 
192
         *dst++ = value;
 
193
 
 
194
         src += 8;
 
195
      }
 
196
 
 
197
      if (x < width) {
 
198
         r  = src[0];
 
199
         g0 = src[1];
 
200
         g1 = 0;
 
201
         b  = src[2];
 
202
 
 
203
         value  = float_to_ubyte(r);
 
204
         value |= float_to_ubyte(g0) <<  8;
 
205
         value |= float_to_ubyte(b)  << 16;
 
206
         value |= float_to_ubyte(g1) << 24;
 
207
 
 
208
#ifdef PIPE_ARCH_BIG_ENDIAN
 
209
         value = util_bswap32(value);
 
210
#endif
 
211
 
 
212
         *dst = value;
 
213
      }
 
214
 
 
215
      dst_row += dst_stride/sizeof(*dst_row);
 
216
      src_row += src_stride/sizeof(*src_row);
 
217
   }
 
218
}
 
219
 
 
220
 
 
221
void
 
222
util_format_r8g8_b8g8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 
223
                                        const uint8_t *src_row, unsigned src_stride,
 
224
                                        unsigned width, unsigned height)
 
225
{
 
226
   unsigned x, y;
 
227
 
 
228
   for (y = 0; y < height; y += 1) {
 
229
      const uint8_t *src = src_row;
 
230
      uint32_t *dst = (uint32_t *)dst_row;
 
231
      uint32_t r, g0, g1, b;
 
232
      uint32_t value;
 
233
 
 
234
      for (x = 0; x + 1 < width; x += 2) {
 
235
         r  = (src[0] + src[4] + 1) >> 1;
 
236
         g0 = src[1];
 
237
         g1 = src[5];
 
238
         b  = (src[2] + src[6] + 1) >> 1;
 
239
 
 
240
         value  = r;
 
241
         value |= g0 <<  8;
 
242
         value |= b  << 16;
 
243
         value |= g1 << 24;
 
244
 
 
245
#ifdef PIPE_ARCH_BIG_ENDIAN
 
246
         value = util_bswap32(value);
 
247
#endif
 
248
 
 
249
         *dst++ = value;
 
250
 
 
251
         src += 8;
 
252
      }
 
253
 
 
254
      if (x < width) {
 
255
         r  = src[0];
 
256
         g0 = src[1];
 
257
         g1 = 0;
 
258
         b  = src[2];
 
259
 
 
260
         value  = r;
 
261
         value |= g0 <<  8;
 
262
         value |= b  << 16;
 
263
         value |= g1 << 24;
 
264
 
 
265
#ifdef PIPE_ARCH_BIG_ENDIAN
 
266
         value = util_bswap32(value);
 
267
#endif
 
268
 
 
269
         *dst = value;
 
270
      }
 
271
 
 
272
      dst_row += dst_stride/sizeof(*dst_row);
 
273
      src_row += src_stride/sizeof(*src_row);
 
274
   }
 
275
}
 
276
 
 
277
 
 
278
void
 
279
util_format_r8g8_b8g8_unorm_fetch_rgba_float(float *dst, const uint8_t *src,
 
280
                                        unsigned i, unsigned j)
 
281
{
 
282
   assert(i < 2);
 
283
   assert(j < 1);
 
284
 
 
285
   dst[0] = ubyte_to_float(src[0]);             /* r */
 
286
   dst[1] = ubyte_to_float(src[1 + 2*i]);       /* g */
 
287
   dst[2] = ubyte_to_float(src[2]);             /* b */
 
288
   dst[3] = 1.0f;                               /* a */
 
289
}
 
290
 
 
291
 
 
292
void
 
293
util_format_g8r8_g8b8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 
294
                                         const uint8_t *src_row, unsigned src_stride,
 
295
                                         unsigned width, unsigned height)
 
296
{
 
297
   unsigned x, y;
 
298
 
 
299
   for (y = 0; y < height; y += 1) {
 
300
      float *dst = dst_row;
 
301
      const uint32_t *src = (const uint32_t *)src_row;
 
302
      uint32_t value;
 
303
      float r, g0, g1, b;
 
304
 
 
305
      for (x = 0; x + 1 < width; x += 2) {
 
306
         value = *src++;
 
307
 
 
308
#ifdef PIPE_ARCH_BIG_ENDIAN
 
309
         value = util_bswap32(value);
 
310
#endif
 
311
 
 
312
         g0 = ubyte_to_float((value >>  0) & 0xff);
 
313
         r  = ubyte_to_float((value >>  8) & 0xff);
 
314
         g1 = ubyte_to_float((value >> 16) & 0xff);
 
315
         b  = ubyte_to_float((value >> 24) & 0xff);
 
316
 
 
317
         dst[0] = r;    /* r */
 
318
         dst[1] = g0;   /* g */
 
319
         dst[2] = b;    /* b */
 
320
         dst[3] = 1.0f; /* a */
 
321
         dst += 4;
 
322
 
 
323
         dst[0] = r;    /* r */
 
324
         dst[1] = g1;   /* g */
 
325
         dst[2] = b;    /* b */
 
326
         dst[3] = 1.0f; /* a */
 
327
         dst += 4;
 
328
      }
 
329
 
 
330
      if (x < width) {
 
331
         value = *src;
 
332
 
 
333
#ifdef PIPE_ARCH_BIG_ENDIAN
 
334
         value = util_bswap32(value);
 
335
#endif
 
336
 
 
337
         g0 = ubyte_to_float((value >>  0) & 0xff);
 
338
         r  = ubyte_to_float((value >>  8) & 0xff);
 
339
         g1 = ubyte_to_float((value >> 16) & 0xff);
 
340
         b  = ubyte_to_float((value >> 24) & 0xff);
 
341
 
 
342
         dst[0] = r;    /* r */
 
343
         dst[1] = g0;   /* g */
 
344
         dst[2] = b;    /* b */
 
345
         dst[3] = 1.0f; /* a */
 
346
      }
 
347
 
 
348
      src_row += src_stride/sizeof(*src_row);
 
349
      dst_row += dst_stride/sizeof(*dst_row);
 
350
   }
 
351
}
 
352
 
 
353
 
 
354
void
 
355
util_format_g8r8_g8b8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 
356
                                          const uint8_t *src_row, unsigned src_stride,
 
357
                                          unsigned width, unsigned height)
 
358
{
 
359
   unsigned x, y;
 
360
 
 
361
   for (y = 0; y < height; y += 1) {
 
362
      uint8_t *dst = dst_row;
 
363
      const uint32_t *src = (const uint32_t *)src_row;
 
364
      uint32_t value;
 
365
      uint8_t r, g0, g1, b;
 
366
 
 
367
      for (x = 0; x + 1 < width; x += 2) {
 
368
         value = *src++;
 
369
 
 
370
#ifdef PIPE_ARCH_BIG_ENDIAN
 
371
         value = util_bswap32(value);
 
372
#endif
 
373
 
 
374
         g0 = (value >>  0) & 0xff;
 
375
         r  = (value >>  8) & 0xff;
 
376
         g1 = (value >> 16) & 0xff;
 
377
         b  = (value >> 24) & 0xff;
 
378
 
 
379
         dst[0] = r;    /* r */
 
380
         dst[1] = g0;   /* g */
 
381
         dst[2] = b;    /* b */
 
382
         dst[3] = 0xff; /* a */
 
383
         dst += 4;
 
384
 
 
385
         dst[0] = r;    /* r */
 
386
         dst[1] = g1;   /* g */
 
387
         dst[2] = b;    /* b */
 
388
         dst[3] = 0xff; /* a */
 
389
         dst += 4;
 
390
      }
 
391
 
 
392
      if (x < width) {
 
393
         value = *src;
 
394
 
 
395
#ifdef PIPE_ARCH_BIG_ENDIAN
 
396
         value = util_bswap32(value);
 
397
#endif
 
398
 
 
399
         g0 = (value >>  0) & 0xff;
 
400
         r  = (value >>  8) & 0xff;
 
401
         g1 = (value >> 16) & 0xff;
 
402
         b  = (value >> 24) & 0xff;
 
403
 
 
404
         dst[0] = r;    /* r */
 
405
         dst[1] = g0;   /* g */
 
406
         dst[2] = b;    /* b */
 
407
         dst[3] = 0xff; /* a */
 
408
      }
 
409
 
 
410
      src_row += src_stride/sizeof(*src_row);
 
411
      dst_row += dst_stride/sizeof(*dst_row);
 
412
   }
 
413
}
 
414
 
 
415
 
 
416
void
 
417
util_format_g8r8_g8b8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
 
418
                                       const float *src_row, unsigned src_stride,
 
419
                                       unsigned width, unsigned height)
 
420
{
 
421
   unsigned x, y;
 
422
 
 
423
   for (y = 0; y < height; y += 1) {
 
424
      const float *src = src_row;
 
425
      uint32_t *dst = (uint32_t *)dst_row;
 
426
      float r, g0, g1, b;
 
427
      uint32_t value;
 
428
 
 
429
      for (x = 0; x + 1 < width; x += 2) {
 
430
         r  = 0.5f*(src[0] + src[4]);
 
431
         g0 = src[1];
 
432
         g1 = src[5];
 
433
         b  = 0.5f*(src[2] + src[6]);
 
434
 
 
435
         value  = float_to_ubyte(g0);
 
436
         value |= float_to_ubyte(r)  <<  8;
 
437
         value |= float_to_ubyte(g1) << 16;
 
438
         value |= float_to_ubyte(b)  << 24;
 
439
 
 
440
#ifdef PIPE_ARCH_BIG_ENDIAN
 
441
         value = util_bswap32(value);
 
442
#endif
 
443
 
 
444
         *dst++ = value;
 
445
 
 
446
         src += 8;
 
447
      }
 
448
 
 
449
      if (x < width) {
 
450
         r  = src[0];
 
451
         g0 = src[1];
 
452
         g1 = 0;
 
453
         b  = src[2];
 
454
 
 
455
         value  = float_to_ubyte(g0);
 
456
         value |= float_to_ubyte(r)  <<  8;
 
457
         value |= float_to_ubyte(g1) << 16;
 
458
         value |= float_to_ubyte(b)  << 24;
 
459
 
 
460
#ifdef PIPE_ARCH_BIG_ENDIAN
 
461
         value = util_bswap32(value);
 
462
#endif
 
463
 
 
464
         *dst = value;
 
465
      }
 
466
 
 
467
      dst_row += dst_stride/sizeof(*dst_row);
 
468
      src_row += src_stride/sizeof(*src_row);
 
469
   }
 
470
}
 
471
 
 
472
 
 
473
void
 
474
util_format_g8r8_g8b8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 
475
                                        const uint8_t *src_row, unsigned src_stride,
 
476
                                        unsigned width, unsigned height)
 
477
{
 
478
   unsigned x, y;
 
479
 
 
480
   for (y = 0; y < height; y += 1) {
 
481
      const uint8_t *src = src_row;
 
482
      uint32_t *dst = (uint32_t *)dst_row;
 
483
      uint32_t r, g0, g1, b;
 
484
      uint32_t value;
 
485
 
 
486
      for (x = 0; x + 1 < width; x += 2) {
 
487
         r  = (src[0] + src[4] + 1) >> 1;
 
488
         g0 = src[1];
 
489
         g1 = src[5];
 
490
         b  = (src[2] + src[6] + 1) >> 1;
 
491
 
 
492
         value  = g0;
 
493
         value |= r  <<  8;
 
494
         value |= g1 << 16;
 
495
         value |= b  << 24;
 
496
 
 
497
#ifdef PIPE_ARCH_BIG_ENDIAN
 
498
         value = util_bswap32(value);
 
499
#endif
 
500
 
 
501
         *dst++ = value;
 
502
 
 
503
         src += 8;
 
504
      }
 
505
 
 
506
      if (x < width) {
 
507
         r  = src[0];
 
508
         g0 = src[1];
 
509
         g1 = 0;
 
510
         b  = src[2];
 
511
 
 
512
         value  = g0;
 
513
         value |= r  <<  8;
 
514
         value |= g1 << 16;
 
515
         value |= b  << 24;
 
516
 
 
517
#ifdef PIPE_ARCH_BIG_ENDIAN
 
518
         value = util_bswap32(value);
 
519
#endif
 
520
 
 
521
         *dst = value;
 
522
      }
 
523
 
 
524
      dst_row += dst_stride/sizeof(*dst_row);
 
525
      src_row += src_stride/sizeof(*src_row);
 
526
   }
 
527
}
 
528
 
 
529
 
 
530
void
 
531
util_format_g8r8_g8b8_unorm_fetch_rgba_float(float *dst, const uint8_t *src,
 
532
                                        unsigned i, unsigned j)
 
533
{
 
534
   assert(i < 2);
 
535
   assert(j < 1);
 
536
 
 
537
   dst[0] = ubyte_to_float(src[1]);             /* r */
 
538
   dst[1] = ubyte_to_float(src[0 + 2*i]);       /* g */
 
539
   dst[2] = ubyte_to_float(src[3]);             /* b */
 
540
   dst[3] = 1.0f;                               /* a */
 
541
}
 
542
 
 
543
 
 
544
void
 
545
util_format_uyvy_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 
546
                              const uint8_t *src_row, unsigned src_stride,
 
547
                              unsigned width, unsigned height)
 
548
{
 
549
   unsigned x, y;
 
550
 
 
551
   for (y = 0; y < height; y += 1) {
 
552
      float *dst = dst_row;
 
553
      const uint32_t *src = (const uint32_t *)src_row;
 
554
      uint32_t value;
 
555
      uint8_t y0, y1, u, v;
 
556
 
 
557
      for (x = 0; x + 1 < width; x += 2) {
 
558
         value = *src++;
 
559
 
 
560
#ifdef PIPE_ARCH_BIG_ENDIAN
 
561
         value = util_bswap32(value);
 
562
#endif
 
563
 
 
564
         u  = (value >>  0) & 0xff;
 
565
         y0 = (value >>  8) & 0xff;
 
566
         v  = (value >> 16) & 0xff;
 
567
         y1 = (value >> 24) & 0xff;
 
568
 
 
569
         util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
 
570
         dst[3] = 1.0f; /* a */
 
571
         dst += 4;
 
572
 
 
573
         util_format_yuv_to_rgb_float(y1, u, v, &dst[0], &dst[1], &dst[2]);
 
574
         dst[3] = 1.0f; /* a */
 
575
         dst += 4;
 
576
      }
 
577
 
 
578
      if (x < width) {
 
579
         value = *src;
 
580
 
 
581
#ifdef PIPE_ARCH_BIG_ENDIAN
 
582
         value = util_bswap32(value);
 
583
#endif
 
584
 
 
585
         u  = (value >>  0) & 0xff;
 
586
         y0 = (value >>  8) & 0xff;
 
587
         v  = (value >> 16) & 0xff;
 
588
         y1 = (value >> 24) & 0xff;
 
589
 
 
590
         util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
 
591
         dst[3] = 1.0f; /* a */
 
592
      }
 
593
 
 
594
      src_row += src_stride/sizeof(*src_row);
 
595
      dst_row += dst_stride/sizeof(*dst_row);
 
596
   }
 
597
}
 
598
 
 
599
 
 
600
void
 
601
util_format_uyvy_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 
602
                               const uint8_t *src_row, unsigned src_stride,
 
603
                               unsigned width, unsigned height)
 
604
{
 
605
   unsigned x, y;
 
606
 
 
607
   for (y = 0; y < height; y += 1) {
 
608
      uint8_t *dst = dst_row;
 
609
      const uint32_t *src = (const uint32_t *)src_row;
 
610
      uint32_t value;
 
611
      uint8_t y0, y1, u, v;
 
612
 
 
613
      for (x = 0; x + 1 < width; x += 2) {
 
614
         value = *src++;
 
615
 
 
616
#ifdef PIPE_ARCH_BIG_ENDIAN
 
617
         value = util_bswap32(value);
 
618
#endif
 
619
 
 
620
         u  = (value >>  0) & 0xff;
 
621
         y0 = (value >>  8) & 0xff;
 
622
         v  = (value >> 16) & 0xff;
 
623
         y1 = (value >> 24) & 0xff;
 
624
 
 
625
         util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
 
626
         dst[3] = 0xff; /* a */
 
627
         dst += 4;
 
628
 
 
629
         util_format_yuv_to_rgb_8unorm(y1, u, v, &dst[0], &dst[1], &dst[2]);
 
630
         dst[3] = 0xff; /* a */
 
631
         dst += 4;
 
632
      }
 
633
 
 
634
      if (x < width) {
 
635
         value = *src;
 
636
 
 
637
#ifdef PIPE_ARCH_BIG_ENDIAN
 
638
         value = util_bswap32(value);
 
639
#endif
 
640
 
 
641
         u  = (value >>  0) & 0xff;
 
642
         y0 = (value >>  8) & 0xff;
 
643
         v  = (value >> 16) & 0xff;
 
644
         y1 = (value >> 24) & 0xff;
 
645
 
 
646
         util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
 
647
         dst[3] = 0xff; /* a */
 
648
      }
 
649
 
 
650
      src_row += src_stride/sizeof(*src_row);
 
651
      dst_row += dst_stride/sizeof(*dst_row);
 
652
   }
 
653
}
 
654
 
 
655
 
 
656
void
 
657
util_format_uyvy_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
 
658
                            const float *src_row, unsigned src_stride,
 
659
                            unsigned width, unsigned height)
 
660
{
 
661
   unsigned x, y;
 
662
 
 
663
   for (y = 0; y < height; y += 1) {
 
664
      const float *src = src_row;
 
665
      uint32_t *dst = (uint32_t *)dst_row;
 
666
      uint8_t y0, y1, u, v;
 
667
      uint32_t value;
 
668
 
 
669
      for (x = 0; x + 1 < width; x += 2) {
 
670
         uint8_t y0, y1, u0, u1, v0, v1, u, v;
 
671
 
 
672
         util_format_rgb_float_to_yuv(src[0], src[1], src[2],
 
673
                                      &y0, &u0, &v0);
 
674
         util_format_rgb_float_to_yuv(src[4], src[5], src[6],
 
675
                                      &y1, &u1, &v1);
 
676
 
 
677
         u = (u0 + u1 + 1) >> 1;
 
678
         v = (v0 + v1 + 1) >> 1;
 
679
 
 
680
         value  = u;
 
681
         value |= y0 <<  8;
 
682
         value |= v  << 16;
 
683
         value |= y1 << 24;
 
684
 
 
685
#ifdef PIPE_ARCH_BIG_ENDIAN
 
686
         value = util_bswap32(value);
 
687
#endif
 
688
 
 
689
         *dst++ = value;
 
690
 
 
691
         src += 8;
 
692
      }
 
693
 
 
694
      if (x < width) {
 
695
         util_format_rgb_float_to_yuv(src[0], src[1], src[2],
 
696
                                      &y0, &u, &v);
 
697
         y1 = 0;
 
698
 
 
699
         value  = u;
 
700
         value |= y0 <<  8;
 
701
         value |= v  << 16;
 
702
         value |= y1 << 24;
 
703
 
 
704
#ifdef PIPE_ARCH_BIG_ENDIAN
 
705
         value = util_bswap32(value);
 
706
#endif
 
707
 
 
708
         *dst = value;
 
709
      }
 
710
 
 
711
      dst_row += dst_stride/sizeof(*dst_row);
 
712
      src_row += src_stride/sizeof(*src_row);
 
713
   }
 
714
}
 
715
 
 
716
 
 
717
void
 
718
util_format_uyvy_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 
719
                             const uint8_t *src_row, unsigned src_stride,
 
720
                             unsigned width, unsigned height)
 
721
{
 
722
   unsigned x, y;
 
723
 
 
724
   for (y = 0; y < height; y += 1) {
 
725
      const uint8_t *src = src_row;
 
726
      uint32_t *dst = (uint32_t *)dst_row;
 
727
      uint8_t y0, y1, u, v;
 
728
      uint32_t value;
 
729
 
 
730
      for (x = 0; x + 1 < width; x += 2) {
 
731
         uint8_t y0, y1, u0, u1, v0, v1, u, v;
 
732
 
 
733
         util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
 
734
                                       &y0, &u0, &v0);
 
735
         util_format_rgb_8unorm_to_yuv(src[4], src[5], src[6],
 
736
                                       &y1, &u1, &v1);
 
737
 
 
738
         u = (u0 + u1 + 1) >> 1;
 
739
         v = (v0 + v1 + 1) >> 1;
 
740
 
 
741
         value  = u;
 
742
         value |= y0 <<  8;
 
743
         value |= v  << 16;
 
744
         value |= y1 << 24;
 
745
 
 
746
#ifdef PIPE_ARCH_BIG_ENDIAN
 
747
         value = util_bswap32(value);
 
748
#endif
 
749
 
 
750
         *dst++ = value;
 
751
 
 
752
         src += 8;
 
753
      }
 
754
 
 
755
      if (x < width) {
 
756
         util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
 
757
                                       &y0, &u, &v);
 
758
         y1 = 0;
 
759
 
 
760
         value  = u;
 
761
         value |= y0 <<  8;
 
762
         value |= v  << 16;
 
763
         value |= y1 << 24;
 
764
 
 
765
#ifdef PIPE_ARCH_BIG_ENDIAN
 
766
         value = util_bswap32(value);
 
767
#endif
 
768
 
 
769
         *dst = value;
 
770
      }
 
771
 
 
772
      dst_row += dst_stride/sizeof(*dst_row);
 
773
      src_row += src_stride/sizeof(*src_row);
 
774
   }
 
775
}
 
776
 
 
777
 
 
778
void
 
779
util_format_uyvy_fetch_rgba_float(float *dst, const uint8_t *src,
 
780
                             unsigned i, unsigned j)
 
781
{
 
782
   uint8_t y, u, v;
 
783
 
 
784
   assert(i < 2);
 
785
   assert(j < 1);
 
786
 
 
787
   y = src[1 + i*2];
 
788
   u = src[0];
 
789
   v = src[2];
 
790
 
 
791
   util_format_yuv_to_rgb_float(y, u, v, &dst[0], &dst[1], &dst[2]);
 
792
 
 
793
   dst[3] = 1.0f;
 
794
}
 
795
 
 
796
 
 
797
void
 
798
util_format_yuyv_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 
799
                              const uint8_t *src_row, unsigned src_stride,
 
800
                              unsigned width, unsigned height)
 
801
{
 
802
   unsigned x, y;
 
803
 
 
804
   for (y = 0; y < height; y += 1) {
 
805
      float *dst = dst_row;
 
806
      const uint32_t *src = (const uint32_t *)src_row;
 
807
      uint32_t value;
 
808
      uint8_t y0, y1, u, v;
 
809
 
 
810
      for (x = 0; x + 1 < width; x += 2) {
 
811
         value = *src++;
 
812
 
 
813
#ifdef PIPE_ARCH_BIG_ENDIAN
 
814
         value = util_bswap32(value);
 
815
#endif
 
816
 
 
817
         y0 = (value >>  0) & 0xff;
 
818
         u  = (value >>  8) & 0xff;
 
819
         y1 = (value >> 16) & 0xff;
 
820
         v  = (value >> 24) & 0xff;
 
821
 
 
822
         util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
 
823
         dst[3] = 1.0f; /* a */
 
824
         dst += 4;
 
825
 
 
826
         util_format_yuv_to_rgb_float(y1, u, v, &dst[0], &dst[1], &dst[2]);
 
827
         dst[3] = 1.0f; /* a */
 
828
         dst += 4;
 
829
      }
 
830
 
 
831
      if (x < width) {
 
832
         value = *src;
 
833
 
 
834
#ifdef PIPE_ARCH_BIG_ENDIAN
 
835
         value = util_bswap32(value);
 
836
#endif
 
837
 
 
838
         y0 = (value >>  0) & 0xff;
 
839
         u  = (value >>  8) & 0xff;
 
840
         y1 = (value >> 16) & 0xff;
 
841
         v  = (value >> 24) & 0xff;
 
842
 
 
843
         util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
 
844
         dst[3] = 1.0f; /* a */
 
845
      }
 
846
 
 
847
      src_row += src_stride/sizeof(*src_row);
 
848
      dst_row += dst_stride/sizeof(*dst_row);
 
849
   }
 
850
}
 
851
 
 
852
 
 
853
void
 
854
util_format_yuyv_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 
855
                               const uint8_t *src_row, unsigned src_stride,
 
856
                               unsigned width, unsigned height)
 
857
{
 
858
   unsigned x, y;
 
859
 
 
860
   for (y = 0; y < height; y += 1) {
 
861
      uint8_t *dst = dst_row;
 
862
      const uint32_t *src = (const uint32_t *)src_row;
 
863
      uint32_t value;
 
864
      uint8_t y0, y1, u, v;
 
865
 
 
866
      for (x = 0; x + 1 < width; x += 2) {
 
867
         value = *src++;
 
868
 
 
869
#ifdef PIPE_ARCH_BIG_ENDIAN
 
870
         value = util_bswap32(value);
 
871
#endif
 
872
 
 
873
         y0 = (value >>  0) & 0xff;
 
874
         u  = (value >>  8) & 0xff;
 
875
         y1 = (value >> 16) & 0xff;
 
876
         v  = (value >> 24) & 0xff;
 
877
 
 
878
         util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
 
879
         dst[3] = 0xff; /* a */
 
880
         dst += 4;
 
881
 
 
882
         util_format_yuv_to_rgb_8unorm(y1, u, v, &dst[0], &dst[1], &dst[2]);
 
883
         dst[3] = 0xff; /* a */
 
884
         dst += 4;
 
885
      }
 
886
 
 
887
      if (x < width) {
 
888
         value = *src;
 
889
 
 
890
#ifdef PIPE_ARCH_BIG_ENDIAN
 
891
         value = util_bswap32(value);
 
892
#endif
 
893
 
 
894
         y0 = (value >>  0) & 0xff;
 
895
         u  = (value >>  8) & 0xff;
 
896
         y1 = (value >> 16) & 0xff;
 
897
         v  = (value >> 24) & 0xff;
 
898
 
 
899
         util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
 
900
         dst[3] = 0xff; /* a */
 
901
      }
 
902
 
 
903
      src_row += src_stride/sizeof(*src_row);
 
904
      dst_row += dst_stride/sizeof(*dst_row);
 
905
   }
 
906
}
 
907
 
 
908
 
 
909
void
 
910
util_format_yuyv_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
 
911
                            const float *src_row, unsigned src_stride,
 
912
                            unsigned width, unsigned height)
 
913
{
 
914
   unsigned x, y;
 
915
 
 
916
   for (y = 0; y < height; y += 1) {
 
917
      const float *src = src_row;
 
918
      uint32_t *dst = (uint32_t *)dst_row;
 
919
      uint8_t y0, y1, u, v;
 
920
      uint32_t value;
 
921
 
 
922
      for (x = 0; x + 1 < width; x += 2) {
 
923
         uint8_t y0, y1, u0, u1, v0, v1, u, v;
 
924
 
 
925
         util_format_rgb_float_to_yuv(src[0], src[1], src[2],
 
926
                                      &y0, &u0, &v0);
 
927
         util_format_rgb_float_to_yuv(src[4], src[5], src[6],
 
928
                                      &y1, &u1, &v1);
 
929
 
 
930
         u = (u0 + u1 + 1) >> 1;
 
931
         v = (v0 + v1 + 1) >> 1;
 
932
 
 
933
         value  = y0;
 
934
         value |= u  <<  8;
 
935
         value |= y1 << 16;
 
936
         value |= v  << 24;
 
937
 
 
938
#ifdef PIPE_ARCH_BIG_ENDIAN
 
939
         value = util_bswap32(value);
 
940
#endif
 
941
 
 
942
         *dst++ = value;
 
943
 
 
944
         src += 8;
 
945
      }
 
946
 
 
947
      if (x < width) {
 
948
         util_format_rgb_float_to_yuv(src[0], src[1], src[2],
 
949
                                      &y0, &u, &v);
 
950
         y1 = 0;
 
951
 
 
952
         value  = y0;
 
953
         value |= u  <<  8;
 
954
         value |= y1 << 16;
 
955
         value |= v  << 24;
 
956
 
 
957
#ifdef PIPE_ARCH_BIG_ENDIAN
 
958
         value = util_bswap32(value);
 
959
#endif
 
960
 
 
961
         *dst = value;
 
962
      }
 
963
 
 
964
      dst_row += dst_stride/sizeof(*dst_row);
 
965
      src_row += src_stride/sizeof(*src_row);
 
966
   }
 
967
}
 
968
 
 
969
 
 
970
void
 
971
util_format_yuyv_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 
972
                             const uint8_t *src_row, unsigned src_stride,
 
973
                             unsigned width, unsigned height)
 
974
{
 
975
   unsigned x, y;
 
976
 
 
977
   for (y = 0; y < height; y += 1) {
 
978
      const uint8_t *src = src_row;
 
979
      uint32_t *dst = (uint32_t *)dst_row;
 
980
      uint8_t y0, y1, u, v;
 
981
      uint32_t value;
 
982
 
 
983
      for (x = 0; x + 1 < width; x += 2) {
 
984
         uint8_t y0, y1, u0, u1, v0, v1, u, v;
 
985
 
 
986
         util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
 
987
                                       &y0, &u0, &v0);
 
988
         util_format_rgb_8unorm_to_yuv(src[4], src[5], src[6],
 
989
                                       &y1, &u1, &v1);
 
990
 
 
991
         u = (u0 + u1 + 1) >> 1;
 
992
         v = (v0 + v1 + 1) >> 1;
 
993
 
 
994
         value  = y0;
 
995
         value |= u  <<  8;
 
996
         value |= y1 << 16;
 
997
         value |= v  << 24;
 
998
 
 
999
#ifdef PIPE_ARCH_BIG_ENDIAN
 
1000
         value = util_bswap32(value);
 
1001
#endif
 
1002
 
 
1003
         *dst++ = value;
 
1004
 
 
1005
         src += 8;
 
1006
      }
 
1007
 
 
1008
      if (x < width) {
 
1009
         util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
 
1010
                                       &y0, &u, &v);
 
1011
         y1 = 0;
 
1012
 
 
1013
         value  = y0;
 
1014
         value |= u  <<  8;
 
1015
         value |= y1 << 16;
 
1016
         value |= v  << 24;
 
1017
 
 
1018
#ifdef PIPE_ARCH_BIG_ENDIAN
 
1019
         value = util_bswap32(value);
 
1020
#endif
 
1021
 
 
1022
         *dst = value;
 
1023
      }
 
1024
 
 
1025
      dst_row += dst_stride/sizeof(*dst_row);
 
1026
      src_row += src_stride/sizeof(*src_row);
 
1027
   }
 
1028
}
 
1029
 
 
1030
 
 
1031
void
 
1032
util_format_yuyv_fetch_rgba_float(float *dst, const uint8_t *src,
 
1033
                             unsigned i, unsigned j)
 
1034
{
 
1035
   uint8_t y, u, v;
 
1036
 
 
1037
   assert(i < 2);
 
1038
   assert(j < 1);
 
1039
 
 
1040
   y = src[0 + i*2];
 
1041
   u = src[1];
 
1042
   v = src[3];
 
1043
 
 
1044
   util_format_yuv_to_rgb_float(y, u, v, &dst[0], &dst[1], &dst[2]);
 
1045
 
 
1046
   dst[3] = 1.0f;
 
1047
}