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