Subversion Repositories shark

Rev

Rev 55 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
55 pj 1
/* $Id: image.c,v 1.1 2003-02-28 11:42:02 pj Exp $ */
2
 
3
/*
4
 * Mesa 3-D graphics library
5
 * Version:  4.1
6
 *
7
 * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
8
 *
9
 * Permission is hereby granted, free of charge, to any person obtaining a
10
 * copy of this software and associated documentation files (the "Software"),
11
 * to deal in the Software without restriction, including without limitation
12
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13
 * and/or sell copies of the Software, and to permit persons to whom the
14
 * Software is furnished to do so, subject to the following conditions:
15
 *
16
 * The above copyright notice and this permission notice shall be included
17
 * in all copies or substantial portions of the Software.
18
 *
19
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
22
 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
 */
26
 
27
#include "glheader.h"
28
#include "colormac.h"
29
#include "context.h"
30
#include "image.h"
31
#include "imports.h"
32
#include "histogram.h"
33
#include "macros.h"
34
#include "mmath.h"
35
#include "pixel.h"
36
#include "mtypes.h"
37
 
38
 
39
/*
40
 * These are the image packing parameters for Mesa's internal images.
41
 * That is, _mesa_unpack_image() returns image data in this format.
42
 * When we execute image commands (glDrawPixels, glTexImage, etc)
43
 * from within display lists we have to be sure to set the current
44
 * unpacking params to these values!
45
 */
46
const struct gl_pixelstore_attrib _mesa_native_packing = {
47
   1,            /* Alignment */
48
   0,            /* RowLength */
49
   0,            /* SkipPixels */
50
   0,            /* SkipRows */
51
   0,            /* ImageHeight */
52
   0,            /* SkipImages */
53
   GL_FALSE,     /* SwapBytes */
54
   GL_FALSE,     /* LsbFirst */
55
   GL_FALSE,     /* ClientStorage */
56
   GL_FALSE      /* Invert */
57
};
58
 
59
 
60
 
61
/*
62
 * Flip the 8 bits in each byte of the given array.
63
 *
64
 * XXX try this trick to flip bytes someday:
65
 *  v = ((v & 0x55555555) << 1) | ((v >> 1) & 0x55555555);
66
 *  v = ((v & 0x33333333) << 2) | ((v >> 2) & 0x33333333);
67
 *  v = ((v & 0x0f0f0f0f) << 4) | ((v >> 4) & 0x0f0f0f0f);
68
 */
69
static void
70
flip_bytes( GLubyte *p, GLuint n )
71
{
72
   register GLuint i, a, b;
73
 
74
   for (i=0;i<n;i++) {
75
      b = (GLuint) p[i];        /* words are often faster than bytes */
76
      a = ((b & 0x01) << 7) |
77
          ((b & 0x02) << 5) |
78
          ((b & 0x04) << 3) |
79
          ((b & 0x08) << 1) |
80
          ((b & 0x10) >> 1) |
81
          ((b & 0x20) >> 3) |
82
          ((b & 0x40) >> 5) |
83
          ((b & 0x80) >> 7);
84
      p[i] = (GLubyte) a;
85
   }
86
}
87
 
88
 
89
/*
90
 * Flip the order of the 2 bytes in each word in the given array.
91
 */
92
void
93
_mesa_swap2( GLushort *p, GLuint n )
94
{
95
   register GLuint i;
96
 
97
   for (i=0;i<n;i++) {
98
      p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
99
   }
100
}
101
 
102
 
103
 
104
/*
105
 * Flip the order of the 4 bytes in each word in the given array.
106
 */
107
void
108
_mesa_swap4( GLuint *p, GLuint n )
109
{
110
   register GLuint i, a, b;
111
 
112
   for (i=0;i<n;i++) {
113
      b = p[i];
114
      a =  (b >> 24)
115
        | ((b >> 8) & 0xff00)
116
        | ((b << 8) & 0xff0000)
117
        | ((b << 24) & 0xff000000);
118
      p[i] = a;
119
   }
120
}
121
 
122
 
123
 
124
 
125
/*
126
 * Return the size, in bytes, of the given GL datatype.
127
 * Return 0 if GL_BITMAP.
128
 * Return -1 if invalid type enum.
129
 */
130
GLint _mesa_sizeof_type( GLenum type )
131
{
132
   switch (type) {
133
      case GL_BITMAP:
134
         return 0;
135
      case GL_UNSIGNED_BYTE:
136
         return sizeof(GLubyte);
137
      case GL_BYTE:
138
         return sizeof(GLbyte);
139
      case GL_UNSIGNED_SHORT:
140
         return sizeof(GLushort);
141
      case GL_SHORT:
142
         return sizeof(GLshort);
143
      case GL_UNSIGNED_INT:
144
         return sizeof(GLuint);
145
      case GL_INT:
146
         return sizeof(GLint);
147
      case GL_FLOAT:
148
         return sizeof(GLfloat);
149
      default:
150
         return -1;
151
   }
152
}
153
 
154
 
155
/*
156
 * Same as _mesa_sizeof_packed_type() but we also accept the
157
 * packed pixel format datatypes.
158
 */
159
GLint _mesa_sizeof_packed_type( GLenum type )
160
{
161
   switch (type) {
162
      case GL_BITMAP:
163
         return 0;
164
      case GL_UNSIGNED_BYTE:
165
         return sizeof(GLubyte);
166
      case GL_BYTE:
167
         return sizeof(GLbyte);
168
      case GL_UNSIGNED_SHORT:
169
         return sizeof(GLushort);
170
      case GL_SHORT:
171
         return sizeof(GLshort);
172
      case GL_UNSIGNED_INT:
173
         return sizeof(GLuint);
174
      case GL_INT:
175
         return sizeof(GLint);
176
      case GL_FLOAT:
177
         return sizeof(GLfloat);
178
      case GL_UNSIGNED_BYTE_3_3_2:
179
         return sizeof(GLubyte);
180
      case GL_UNSIGNED_BYTE_2_3_3_REV:
181
         return sizeof(GLubyte);
182
      case GL_UNSIGNED_SHORT_5_6_5:
183
         return sizeof(GLushort);
184
      case GL_UNSIGNED_SHORT_5_6_5_REV:
185
         return sizeof(GLushort);
186
      case GL_UNSIGNED_SHORT_4_4_4_4:
187
         return sizeof(GLushort);
188
      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
189
         return sizeof(GLushort);
190
      case GL_UNSIGNED_SHORT_5_5_5_1:
191
         return sizeof(GLushort);
192
      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
193
         return sizeof(GLushort);
194
      case GL_UNSIGNED_INT_8_8_8_8:
195
         return sizeof(GLuint);
196
      case GL_UNSIGNED_INT_8_8_8_8_REV:
197
         return sizeof(GLuint);
198
      case GL_UNSIGNED_INT_10_10_10_2:
199
         return sizeof(GLuint);
200
      case GL_UNSIGNED_INT_2_10_10_10_REV:
201
         return sizeof(GLuint);
202
      case GL_UNSIGNED_SHORT_8_8_MESA:
203
      case GL_UNSIGNED_SHORT_8_8_REV_MESA:
204
          return sizeof(GLushort);      
205
      default:
206
         return -1;
207
   }
208
}
209
 
210
 
211
 
212
/*
213
 * Return the number of components in a GL enum pixel type.
214
 * Return -1 if bad format.
215
 */
216
GLint _mesa_components_in_format( GLenum format )
217
{
218
   switch (format) {
219
      case GL_COLOR_INDEX:
220
      case GL_COLOR_INDEX1_EXT:
221
      case GL_COLOR_INDEX2_EXT:
222
      case GL_COLOR_INDEX4_EXT:
223
      case GL_COLOR_INDEX8_EXT:
224
      case GL_COLOR_INDEX12_EXT:
225
      case GL_COLOR_INDEX16_EXT:
226
      case GL_STENCIL_INDEX:
227
      case GL_DEPTH_COMPONENT:
228
      case GL_RED:
229
      case GL_GREEN:
230
      case GL_BLUE:
231
      case GL_ALPHA:
232
      case GL_LUMINANCE:
233
      case GL_INTENSITY:
234
         return 1;
235
      case GL_LUMINANCE_ALPHA:
236
         return 2;
237
      case GL_RGB:
238
         return 3;
239
      case GL_RGBA:
240
         return 4;
241
      case GL_BGR:
242
         return 3;
243
      case GL_BGRA:
244
         return 4;
245
      case GL_ABGR_EXT:
246
         return 4;
247
      case GL_YCBCR_MESA:
248
         return 2;
249
      default:
250
         return -1;
251
   }
252
}
253
 
254
 
255
/*
256
 * Return bytes per pixel for given format and type
257
 * Return -1 if bad format or type.
258
 */
259
GLint _mesa_bytes_per_pixel( GLenum format, GLenum type )
260
{
261
   GLint comps = _mesa_components_in_format( format );
262
   if (comps < 0)
263
      return -1;
264
 
265
   switch (type) {
266
      case GL_BITMAP:
267
         return 0;  /* special case */
268
      case GL_BYTE:
269
      case GL_UNSIGNED_BYTE:
270
         return comps * sizeof(GLubyte);
271
      case GL_SHORT:
272
      case GL_UNSIGNED_SHORT:
273
         return comps * sizeof(GLshort);
274
      case GL_INT:
275
      case GL_UNSIGNED_INT:
276
         return comps * sizeof(GLint);
277
      case GL_FLOAT:
278
         return comps * sizeof(GLfloat);
279
      case GL_UNSIGNED_BYTE_3_3_2:
280
      case GL_UNSIGNED_BYTE_2_3_3_REV:
281
         if (format == GL_RGB || format == GL_BGR)
282
            return sizeof(GLubyte);
283
         else
284
            return -1;  /* error */
285
      case GL_UNSIGNED_SHORT_5_6_5:
286
      case GL_UNSIGNED_SHORT_5_6_5_REV:
287
         if (format == GL_RGB || format == GL_BGR)
288
            return sizeof(GLushort);
289
         else
290
            return -1;  /* error */
291
      case GL_UNSIGNED_SHORT_4_4_4_4:
292
      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
293
      case GL_UNSIGNED_SHORT_5_5_5_1:
294
      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
295
         if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
296
            return sizeof(GLushort);
297
         else
298
            return -1;
299
      case GL_UNSIGNED_INT_8_8_8_8:
300
      case GL_UNSIGNED_INT_8_8_8_8_REV:
301
      case GL_UNSIGNED_INT_10_10_10_2:
302
      case GL_UNSIGNED_INT_2_10_10_10_REV:
303
         if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT)
304
            return sizeof(GLuint);
305
         else
306
            return -1;
307
      case GL_UNSIGNED_SHORT_8_8_MESA:
308
      case GL_UNSIGNED_SHORT_8_8_REV_MESA:
309
         if (format == GL_YCBCR_MESA)
310
            return sizeof(GLushort);
311
         else
312
            return -1;
313
      default:
314
         return -1;
315
   }
316
}
317
 
318
 
319
/*
320
 * Test if the given pixel format and type are legal.
321
 * Return GL_TRUE for legal, GL_FALSE for illegal.
322
 */
323
GLboolean
324
_mesa_is_legal_format_and_type( GLenum format, GLenum type )
325
{
326
   switch (format) {
327
      case GL_COLOR_INDEX:
328
      case GL_STENCIL_INDEX:
329
         switch (type) {
330
            case GL_BITMAP:
331
            case GL_BYTE:
332
            case GL_UNSIGNED_BYTE:
333
            case GL_SHORT:
334
            case GL_UNSIGNED_SHORT:
335
            case GL_INT:
336
            case GL_UNSIGNED_INT:
337
            case GL_FLOAT:
338
               return GL_TRUE;
339
            default:
340
               return GL_FALSE;
341
         }
342
      case GL_RED:
343
      case GL_GREEN:
344
      case GL_BLUE:
345
      case GL_ALPHA:
346
      case GL_INTENSITY:
347
      case GL_LUMINANCE:
348
      case GL_LUMINANCE_ALPHA:
349
      case GL_DEPTH_COMPONENT:
350
         switch (type) {
351
            case GL_BYTE:
352
            case GL_UNSIGNED_BYTE:
353
            case GL_SHORT:
354
            case GL_UNSIGNED_SHORT:
355
            case GL_INT:
356
            case GL_UNSIGNED_INT:
357
            case GL_FLOAT:
358
               return GL_TRUE;
359
            default:
360
               return GL_FALSE;
361
         }
362
      case GL_RGB:
363
      case GL_BGR:
364
         switch (type) {
365
            case GL_BYTE:
366
            case GL_UNSIGNED_BYTE:
367
            case GL_SHORT:
368
            case GL_UNSIGNED_SHORT:
369
            case GL_INT:
370
            case GL_UNSIGNED_INT:
371
            case GL_FLOAT:
372
            case GL_UNSIGNED_BYTE_3_3_2:
373
            case GL_UNSIGNED_BYTE_2_3_3_REV:
374
            case GL_UNSIGNED_SHORT_5_6_5:
375
            case GL_UNSIGNED_SHORT_5_6_5_REV:
376
               return GL_TRUE;
377
            default:
378
               return GL_FALSE;
379
         }
380
      case GL_RGBA:
381
      case GL_BGRA:
382
      case GL_ABGR_EXT:
383
         switch (type) {
384
            case GL_BYTE:
385
            case GL_UNSIGNED_BYTE:
386
            case GL_SHORT:
387
            case GL_UNSIGNED_SHORT:
388
            case GL_INT:
389
            case GL_UNSIGNED_INT:
390
            case GL_FLOAT:
391
            case GL_UNSIGNED_SHORT_4_4_4_4:
392
            case GL_UNSIGNED_SHORT_4_4_4_4_REV:
393
            case GL_UNSIGNED_SHORT_5_5_5_1:
394
            case GL_UNSIGNED_SHORT_1_5_5_5_REV:
395
            case GL_UNSIGNED_INT_8_8_8_8:
396
            case GL_UNSIGNED_INT_8_8_8_8_REV:
397
            case GL_UNSIGNED_INT_10_10_10_2:
398
            case GL_UNSIGNED_INT_2_10_10_10_REV:
399
               return GL_TRUE;
400
            default:
401
               return GL_FALSE;
402
         }
403
      case GL_YCBCR_MESA:
404
         if (type == GL_UNSIGNED_SHORT_8_8_MESA ||
405
             type == GL_UNSIGNED_SHORT_8_8_REV_MESA)
406
            return GL_TRUE;
407
         else
408
            return GL_FALSE;
409
      default:
410
         ; /* fall-through */
411
   }
412
   return GL_FALSE;
413
}
414
 
415
 
416
 
417
/*
418
 * Return the address of a pixel in an image (actually a volume).
419
 * Pixel unpacking/packing parameters are observed according to 'packing'.
420
 * Input:  image - start of image data
421
 *         width, height - size of image
422
 *         format - image format
423
 *         type - pixel component type
424
 *         packing - the pixelstore attributes
425
 *         img - which image in the volume (0 for 1D or 2D images)
426
 *         row, column - location of pixel in the image
427
 * Return:  address of pixel at (image,row,column) in image or NULL if error.
428
 */
429
GLvoid *
430
_mesa_image_address( const struct gl_pixelstore_attrib *packing,
431
                     const GLvoid *image, GLsizei width,
432
                     GLsizei height, GLenum format, GLenum type,
433
                     GLint img, GLint row, GLint column )
434
{
435
   GLint alignment;        /* 1, 2 or 4 */
436
   GLint pixels_per_row;
437
   GLint rows_per_image;
438
   GLint skiprows;
439
   GLint skippixels;
440
   GLint skipimages;       /* for 3-D volume images */
441
   GLubyte *pixel_addr;
442
 
443
   alignment = packing->Alignment;
444
   if (packing->RowLength > 0) {
445
      pixels_per_row = packing->RowLength;
446
   }
447
   else {
448
      pixels_per_row = width;
449
   }
450
   if (packing->ImageHeight > 0) {
451
      rows_per_image = packing->ImageHeight;
452
   }
453
   else {
454
      rows_per_image = height;
455
   }
456
   skiprows = packing->SkipRows;
457
   skippixels = packing->SkipPixels;
458
   skipimages = packing->SkipImages;
459
 
460
   if (type==GL_BITMAP) {
461
      /* BITMAP data */
462
      GLint comp_per_pixel;   /* components per pixel */
463
      GLint bytes_per_comp;   /* bytes per component */
464
      GLint bytes_per_row;
465
      GLint bytes_per_image;
466
 
467
      /* Compute bytes per component */
468
      bytes_per_comp = _mesa_sizeof_packed_type( type );
469
      if (bytes_per_comp<0) {
470
         return NULL;
471
      }
472
 
473
      /* Compute number of components per pixel */
474
      comp_per_pixel = _mesa_components_in_format( format );
475
      if (comp_per_pixel<0 && type != GL_BITMAP) {
476
         return NULL;
477
      }
478
 
479
      bytes_per_row = alignment
480
                    * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
481
 
482
      bytes_per_image = bytes_per_row * rows_per_image;
483
 
484
      pixel_addr = (GLubyte *) image
485
                 + (skipimages + img) * bytes_per_image
486
                 + (skiprows + row) * bytes_per_row
487
                 + (skippixels + column) / 8;
488
   }
489
   else {
490
      /* Non-BITMAP data */
491
      GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image;
492
      GLint topOfImage;
493
 
494
      bytes_per_pixel = _mesa_bytes_per_pixel( format, type );
495
 
496
      /* The pixel type and format should have been error checked earlier */
497
      assert(bytes_per_pixel > 0);
498
 
499
      bytes_per_row = pixels_per_row * bytes_per_pixel;
500
      remainder = bytes_per_row % alignment;
501
      if (remainder > 0)
502
         bytes_per_row += (alignment - remainder);
503
 
504
      ASSERT(bytes_per_row % alignment == 0);
505
 
506
      bytes_per_image = bytes_per_row * rows_per_image;
507
 
508
      if (packing->Invert) {
509
         /* set pixel_addr to the last row */
510
         topOfImage = bytes_per_row * (height - 1);
511
         bytes_per_row = -bytes_per_row;
512
      }
513
      else {
514
         topOfImage = 0;
515
      }
516
 
517
      /* compute final pixel address */
518
      pixel_addr = (GLubyte *) image
519
                 + (skipimages + img) * bytes_per_image
520
                 + topOfImage
521
                 + (skiprows + row) * bytes_per_row
522
                 + (skippixels + column) * bytes_per_pixel;
523
   }
524
 
525
   return (GLvoid *) pixel_addr;
526
}
527
 
528
 
529
 
530
/*
531
 * Compute the stride between image rows (in bytes) for the given
532
 * pixel packing parameters and image width, format and type.
533
 */
534
GLint
535
_mesa_image_row_stride( const struct gl_pixelstore_attrib *packing,
536
                        GLint width, GLenum format, GLenum type )
537
{
538
   ASSERT(packing);
539
   if (type == GL_BITMAP) {
540
      /* BITMAP data */
541
      GLint bytes;
542
      if (packing->RowLength == 0) {
543
         bytes = (width + 7) / 8;
544
      }
545
      else {
546
         bytes = (packing->RowLength + 7) / 8;
547
      }
548
      if (packing->Invert) {
549
         /* negate the bytes per row (negative row stride) */
550
         bytes = -bytes;
551
      }
552
      return bytes;
553
   }
554
   else {
555
      /* Non-BITMAP data */
556
      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
557
      GLint bytesPerRow, remainder;
558
      if (bytesPerPixel <= 0)
559
         return -1;  /* error */
560
      if (packing->RowLength == 0) {
561
         bytesPerRow = bytesPerPixel * width;
562
      }
563
      else {
564
         bytesPerRow = bytesPerPixel * packing->RowLength;
565
      }
566
      remainder = bytesPerRow % packing->Alignment;
567
      if (remainder > 0)
568
         bytesPerRow += (packing->Alignment - remainder);
569
      if (packing->Invert)
570
         bytesPerRow = -bytesPerRow;
571
      return bytesPerRow;
572
   }
573
}
574
 
575
 
576
 
577
/*
578
 * Compute the stride between images in a 3D texture (in bytes) for the given
579
 * pixel packing parameters and image width, format and type.
580
 */
581
GLint
582
_mesa_image_image_stride( const struct gl_pixelstore_attrib *packing,
583
                          GLint width, GLint height,
584
                          GLenum format, GLenum type )
585
{
586
   ASSERT(packing);
587
   ASSERT(type != GL_BITMAP);
588
 
589
   {
590
      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
591
      GLint bytesPerRow, bytesPerImage, remainder;
592
 
593
      if (bytesPerPixel <= 0)
594
         return -1;  /* error */
595
      if (packing->RowLength == 0) {
596
         bytesPerRow = bytesPerPixel * width;
597
      }
598
      else {
599
         bytesPerRow = bytesPerPixel * packing->RowLength;
600
      }
601
      remainder = bytesPerRow % packing->Alignment;
602
      if (remainder > 0)
603
         bytesPerRow += (packing->Alignment - remainder);
604
 
605
      if (packing->ImageHeight == 0)
606
         bytesPerImage = bytesPerRow * height;
607
      else
608
         bytesPerImage = bytesPerRow * packing->ImageHeight;
609
 
610
      return bytesPerImage;
611
   }
612
}
613
 
614
 
615
 
616
 
617
/*
618
 * Unpack a 32x32 pixel polygon stipple from user memory using the
619
 * current pixel unpack settings.
620
 */
621
void
622
_mesa_unpack_polygon_stipple( const GLubyte *pattern, GLuint dest[32],
623
                              const struct gl_pixelstore_attrib *unpacking )
624
{
625
   GLubyte *ptrn = (GLubyte *) _mesa_unpack_bitmap( 32, 32, pattern, unpacking );
626
   if (ptrn) {
627
      /* Convert pattern from GLubytes to GLuints and handle big/little
628
       * endian differences
629
       */
630
      GLubyte *p = ptrn;
631
      GLint i;
632
      for (i = 0; i < 32; i++) {
633
         dest[i] = (p[0] << 24)
634
                 | (p[1] << 16)
635
                 | (p[2] <<  8)
636
                 | (p[3]      );
637
         p += 4;
638
      }
639
      FREE(ptrn);
640
   }
641
}
642
 
643
 
644
 
645
/*
646
 * Pack polygon stipple into user memory given current pixel packing
647
 * settings.
648
 */
649
void
650
_mesa_pack_polygon_stipple( const GLuint pattern[32], GLubyte *dest,
651
                            const struct gl_pixelstore_attrib *packing )
652
{
653
   /* Convert pattern from GLuints to GLubytes to handle big/little
654
    * endian differences.
655
    */
656
   GLubyte ptrn[32*4];
657
   GLint i;
658
   for (i = 0; i < 32; i++) {
659
      ptrn[i * 4 + 0] = (GLubyte) ((pattern[i] >> 24) & 0xff);
660
      ptrn[i * 4 + 1] = (GLubyte) ((pattern[i] >> 16) & 0xff);
661
      ptrn[i * 4 + 2] = (GLubyte) ((pattern[i] >> 8 ) & 0xff);
662
      ptrn[i * 4 + 3] = (GLubyte) ((pattern[i]      ) & 0xff);
663
   }
664
 
665
   _mesa_pack_bitmap(32, 32, ptrn, dest, packing);
666
}
667
 
668
 
669
/*
670
 * Unpack bitmap data.  Resulting data will be in most-significant-bit-first
671
 * order with row alignment = 1 byte.
672
 */
673
GLvoid *
674
_mesa_unpack_bitmap( GLint width, GLint height, const GLubyte *pixels,
675
                     const struct gl_pixelstore_attrib *packing )
676
{
677
   GLint bytes, row, width_in_bytes;
678
   GLubyte *buffer, *dst;
679
 
680
   if (!pixels)
681
      return NULL;
682
 
683
   /* Alloc dest storage */
684
   bytes = ((width + 7) / 8 * height);
685
   buffer = (GLubyte *) MALLOC( bytes );
686
   if (!buffer)
687
      return NULL;
688
 
689
 
690
   width_in_bytes = CEILING( width, 8 );
691
   dst = buffer;
692
   for (row = 0; row < height; row++) {
693
      const GLubyte *src = (const GLubyte *)
694
         _mesa_image_address(packing, pixels, width, height,
695
                             GL_COLOR_INDEX, GL_BITMAP, 0, row, 0);
696
      if (!src) {
697
         FREE(buffer);
698
         return NULL;
699
      }
700
 
701
      if (packing->SkipPixels == 0) {
702
         MEMCPY( dst, src, width_in_bytes );
703
         if (packing->LsbFirst) {
704
            flip_bytes( dst, width_in_bytes );
705
         }
706
      }
707
      else {
708
         /* handling SkipPixels is a bit tricky (no pun intended!) */
709
         GLint i;
710
         if (packing->LsbFirst) {
711
            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
712
            GLubyte dstMask = 128;
713
            const GLubyte *s = src;
714
            GLubyte *d = dst;
715
            *d = 0;
716
            for (i = 0; i < width; i++) {
717
               if (*s & srcMask) {
718
                  *d |= dstMask;
719
               }
720
               if (srcMask == 128) {
721
                  srcMask = 1;
722
                  s++;
723
               }
724
               else {
725
                  srcMask = srcMask << 1;
726
               }
727
               if (dstMask == 1) {
728
                  dstMask = 128;
729
                  d++;
730
                  *d = 0;
731
               }
732
               else {
733
                  dstMask = dstMask >> 1;
734
               }
735
            }
736
         }
737
         else {
738
            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
739
            GLubyte dstMask = 128;
740
            const GLubyte *s = src;
741
            GLubyte *d = dst;
742
            *d = 0;
743
            for (i = 0; i < width; i++) {
744
               if (*s & srcMask) {
745
                  *d |= dstMask;
746
               }
747
               if (srcMask == 1) {
748
                  srcMask = 128;
749
                  s++;
750
               }
751
               else {
752
                  srcMask = srcMask >> 1;
753
               }
754
               if (dstMask == 1) {
755
                  dstMask = 128;
756
                  d++;
757
                  *d = 0;
758
               }
759
               else {
760
                  dstMask = dstMask >> 1;
761
               }
762
            }
763
         }
764
      }
765
      dst += width_in_bytes;
766
   }
767
 
768
   return buffer;
769
}
770
 
771
 
772
/*
773
 * Pack bitmap data.
774
 */
775
void
776
_mesa_pack_bitmap( GLint width, GLint height, const GLubyte *source,
777
                   GLubyte *dest, const struct gl_pixelstore_attrib *packing )
778
{
779
   GLint row, width_in_bytes;
780
   const GLubyte *src;
781
 
782
   if (!source)
783
      return;
784
 
785
   width_in_bytes = CEILING( width, 8 );
786
   src = source;
787
   for (row = 0; row < height; row++) {
788
      GLubyte *dst = (GLubyte *) _mesa_image_address( packing, dest,
789
                       width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 );
790
      if (!dst)
791
         return;
792
 
793
      if (packing->SkipPixels == 0) {
794
         MEMCPY( dst, src, width_in_bytes );
795
         if (packing->LsbFirst) {
796
            flip_bytes( dst, width_in_bytes );
797
         }
798
      }
799
      else {
800
         /* handling SkipPixels is a bit tricky (no pun intended!) */
801
         GLint i;
802
         if (packing->LsbFirst) {
803
            GLubyte srcMask = 1 << (packing->SkipPixels & 0x7);
804
            GLubyte dstMask = 128;
805
            const GLubyte *s = src;
806
            GLubyte *d = dst;
807
            *d = 0;
808
            for (i = 0; i < width; i++) {
809
               if (*s & srcMask) {
810
                  *d |= dstMask;
811
               }
812
               if (srcMask == 128) {
813
                  srcMask = 1;
814
                  s++;
815
               }
816
               else {
817
                  srcMask = srcMask << 1;
818
               }
819
               if (dstMask == 1) {
820
                  dstMask = 128;
821
                  d++;
822
                  *d = 0;
823
               }
824
               else {
825
                  dstMask = dstMask >> 1;
826
               }
827
            }
828
         }
829
         else {
830
            GLubyte srcMask = 128 >> (packing->SkipPixels & 0x7);
831
            GLubyte dstMask = 128;
832
            const GLubyte *s = src;
833
            GLubyte *d = dst;
834
            *d = 0;
835
            for (i = 0; i < width; i++) {
836
               if (*s & srcMask) {
837
                  *d |= dstMask;
838
               }
839
               if (srcMask == 1) {
840
                  srcMask = 128;
841
                  s++;
842
               }
843
               else {
844
                  srcMask = srcMask >> 1;
845
               }
846
               if (dstMask == 1) {
847
                  dstMask = 128;
848
                  d++;
849
                  *d = 0;
850
               }
851
               else {
852
                  dstMask = dstMask >> 1;
853
               }
854
            }
855
         }
856
      }
857
      src += width_in_bytes;
858
   }
859
}
860
 
861
 
862
 
863
/*
864
 * Used to pack an array [][4] of RGBA GLchan colors as specified
865
 * by the dstFormat, dstType and dstPacking.  Used by glReadPixels,
866
 * glGetConvolutionFilter(), etc.
867
 */
868
void
869
_mesa_pack_float_rgba_span( GLcontext *ctx,
870
                            GLuint n, CONST GLfloat rgbaIn[][4],
871
                            GLenum dstFormat, GLenum dstType,
872
                            GLvoid *dstAddr,
873
                            const struct gl_pixelstore_attrib *dstPacking,
874
                            GLuint transferOps )
875
{
876
   const GLint comps = _mesa_components_in_format(dstFormat);
877
   GLfloat luminance[MAX_WIDTH];
878
   GLfloat (*rgba)[4];
879
   GLuint i;
880
 
881
   if (transferOps) {
882
      /* make copy of incoming data */
883
      DEFMARRAY(GLfloat, rgbaCopy, MAX_WIDTH, 4);  /* mac 32k limitation */
884
      CHECKARRAY(rgbaCopy, return);  /* mac 32k limitation */
885
 
886
      for (i = 0; i < n; i++) {
887
         rgbaCopy[i][0] = rgbaIn[i][0];
888
         rgbaCopy[i][1] = rgbaIn[i][1];
889
         rgbaCopy[i][2] = rgbaIn[i][2];
890
         rgbaCopy[i][3] = rgbaIn[i][3];
891
      }
892
 
893
      rgba = (GLfloat (*)[4]) rgbaCopy;
894
 
895
      /* scale & bias */
896
      if (transferOps & IMAGE_SCALE_BIAS_BIT) {
897
         _mesa_scale_and_bias_rgba(ctx, n, rgba,
898
                                   ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
899
                                   ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
900
                                   ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
901
                                   ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
902
      }
903
      /* color map lookup */
904
      if (transferOps & IMAGE_MAP_COLOR_BIT) {
905
         _mesa_map_rgba( ctx, n, rgba );
906
      }
907
      /* GL_COLOR_TABLE lookup */
908
      if (transferOps & IMAGE_COLOR_TABLE_BIT) {
909
         _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
910
      }
911
      /* convolution */
912
      if (transferOps & IMAGE_CONVOLUTION_BIT) {
913
         /* this has to be done in the calling code */
914
      }
915
      /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
916
      if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
917
         _mesa_scale_and_bias_rgba(ctx, n, rgba,
918
                                   ctx->Pixel.PostConvolutionScale[RCOMP],
919
                                   ctx->Pixel.PostConvolutionScale[GCOMP],
920
                                   ctx->Pixel.PostConvolutionScale[BCOMP],
921
                                   ctx->Pixel.PostConvolutionScale[ACOMP],
922
                                   ctx->Pixel.PostConvolutionBias[RCOMP],
923
                                   ctx->Pixel.PostConvolutionBias[GCOMP],
924
                                   ctx->Pixel.PostConvolutionBias[BCOMP],
925
                                   ctx->Pixel.PostConvolutionBias[ACOMP]);
926
      }
927
      /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
928
      if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
929
         _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
930
      }
931
      /* color matrix transform */
932
      if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
933
         _mesa_transform_rgba(ctx, n, rgba);
934
      }
935
      /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
936
      if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
937
         _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
938
      }
939
      /* update histogram count */
940
      if (transferOps & IMAGE_HISTOGRAM_BIT) {
941
         _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
942
      }
943
      /* min/max here */
944
      if (transferOps & IMAGE_MIN_MAX_BIT) {
945
         _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
946
         if (ctx->MinMax.Sink) {
947
            UNDEFARRAY(rgbaCopy);  /* mac 32k limitation */
948
            return;
949
         }
950
      }
951
      UNDEFARRAY(rgbaCopy);  /* mac 32k limitation */
952
   }
953
   else {
954
      /* use incoming data, not a copy */
955
      rgba = (GLfloat (*)[4]) rgbaIn;
956
   }
957
 
958
   /* XXX clamp rgba to [0,1]? */
959
 
960
 
961
   if (dstFormat == GL_LUMINANCE || dstFormat == GL_LUMINANCE_ALPHA) {
962
      for (i = 0; i < n; i++) {
963
         GLfloat sum = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP];
964
#if CHAN_TYPE == GL_FLOAT
965
         luminance[i] = sum;
966
#else
967
         luminance[i] = CLAMP(sum, 0.0F, 1.0F);
968
#endif
969
      }
970
   }
971
 
972
   /*
973
    * Pack/store the pixels.  Ugh!  Lots of cases!!!
974
    */
975
   switch (dstType) {
976
      case GL_UNSIGNED_BYTE:
977
         {
978
            GLubyte *dst = (GLubyte *) dstAddr;
979
            switch (dstFormat) {
980
               case GL_RED:
981
                  for (i=0;i<n;i++)
982
                     dst[i] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
983
                  break;
984
               case GL_GREEN:
985
                  for (i=0;i<n;i++)
986
                     dst[i] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
987
                  break;
988
               case GL_BLUE:
989
                  for (i=0;i<n;i++)
990
                     dst[i] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
991
                  break;
992
               case GL_ALPHA:
993
                  for (i=0;i<n;i++)
994
                     dst[i] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
995
                  break;
996
               case GL_LUMINANCE:
997
                  for (i=0;i<n;i++)
998
                     dst[i] = FLOAT_TO_UBYTE(luminance[i]);
999
                  break;
1000
               case GL_LUMINANCE_ALPHA:
1001
                  for (i=0;i<n;i++) {
1002
                     dst[i*2+0] = FLOAT_TO_UBYTE(luminance[i]);
1003
                     dst[i*2+1] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1004
                  }
1005
                  break;
1006
               case GL_RGB:
1007
                  for (i=0;i<n;i++) {
1008
                     dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1009
                     dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1010
                     dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1011
                  }
1012
                  break;
1013
               case GL_RGBA:
1014
                  for (i=0;i<n;i++) {
1015
                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1016
                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1017
                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1018
                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1019
                  }
1020
                  break;
1021
               case GL_BGR:
1022
                  for (i=0;i<n;i++) {
1023
                     dst[i*3+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1024
                     dst[i*3+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1025
                     dst[i*3+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1026
                  }
1027
                  break;
1028
               case GL_BGRA:
1029
                  for (i=0;i<n;i++) {
1030
                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1031
                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1032
                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1033
                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1034
                  }
1035
                  break;
1036
               case GL_ABGR_EXT:
1037
                  for (i=0;i<n;i++) {
1038
                     dst[i*4+0] = FLOAT_TO_UBYTE(rgba[i][ACOMP]);
1039
                     dst[i*4+1] = FLOAT_TO_UBYTE(rgba[i][BCOMP]);
1040
                     dst[i*4+2] = FLOAT_TO_UBYTE(rgba[i][GCOMP]);
1041
                     dst[i*4+3] = FLOAT_TO_UBYTE(rgba[i][RCOMP]);
1042
                  }
1043
                  break;
1044
               default:
1045
                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1046
            }
1047
         }
1048
         break;
1049
      case GL_BYTE:
1050
         {
1051
            GLbyte *dst = (GLbyte *) dstAddr;
1052
            switch (dstFormat) {
1053
               case GL_RED:
1054
                  for (i=0;i<n;i++)
1055
                     dst[i] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1056
                  break;
1057
               case GL_GREEN:
1058
                  for (i=0;i<n;i++)
1059
                     dst[i] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1060
                  break;
1061
               case GL_BLUE:
1062
                  for (i=0;i<n;i++)
1063
                     dst[i] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1064
                  break;
1065
               case GL_ALPHA:
1066
                  for (i=0;i<n;i++)
1067
                     dst[i] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1068
                  break;
1069
               case GL_LUMINANCE:
1070
                  for (i=0;i<n;i++)
1071
                     dst[i] = FLOAT_TO_BYTE(luminance[i]);
1072
                  break;
1073
               case GL_LUMINANCE_ALPHA:
1074
                  for (i=0;i<n;i++) {
1075
                     dst[i*2+0] = FLOAT_TO_BYTE(luminance[i]);
1076
                     dst[i*2+1] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1077
                  }
1078
                  break;
1079
               case GL_RGB:
1080
                  for (i=0;i<n;i++) {
1081
                     dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1082
                     dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1083
                     dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1084
                  }
1085
                  break;
1086
               case GL_RGBA:
1087
                  for (i=0;i<n;i++) {
1088
                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1089
                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1090
                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1091
                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1092
                  }
1093
                  break;
1094
               case GL_BGR:
1095
                  for (i=0;i<n;i++) {
1096
                     dst[i*3+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1097
                     dst[i*3+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1098
                     dst[i*3+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1099
                  }
1100
                  break;
1101
               case GL_BGRA:
1102
                  for (i=0;i<n;i++) {
1103
                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1104
                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1105
                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1106
                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1107
                  }
1108
               case GL_ABGR_EXT:
1109
                  for (i=0;i<n;i++) {
1110
                     dst[i*4+0] = FLOAT_TO_BYTE(rgba[i][ACOMP]);
1111
                     dst[i*4+1] = FLOAT_TO_BYTE(rgba[i][BCOMP]);
1112
                     dst[i*4+2] = FLOAT_TO_BYTE(rgba[i][GCOMP]);
1113
                     dst[i*4+3] = FLOAT_TO_BYTE(rgba[i][RCOMP]);
1114
                  }
1115
                  break;
1116
               default:
1117
                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1118
            }
1119
         }
1120
         break;
1121
      case GL_UNSIGNED_SHORT:
1122
         {
1123
            GLushort *dst = (GLushort *) dstAddr;
1124
            switch (dstFormat) {
1125
               case GL_RED:
1126
                  for (i=0;i<n;i++)
1127
                     dst[i] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1128
                  break;
1129
               case GL_GREEN:
1130
                  for (i=0;i<n;i++)
1131
                     dst[i] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1132
                  break;
1133
               case GL_BLUE:
1134
                  for (i=0;i<n;i++)
1135
                     dst[i] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1136
                  break;
1137
               case GL_ALPHA:
1138
                  for (i=0;i<n;i++)
1139
                     dst[i] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1140
                  break;
1141
               case GL_LUMINANCE:
1142
                  for (i=0;i<n;i++)
1143
                     dst[i] = FLOAT_TO_USHORT(luminance[i]);
1144
                  break;
1145
               case GL_LUMINANCE_ALPHA:
1146
                  for (i=0;i<n;i++) {
1147
                     dst[i*2+0] = FLOAT_TO_USHORT(luminance[i]);
1148
                     dst[i*2+1] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1149
                  }
1150
                  break;
1151
               case GL_RGB:
1152
                  for (i=0;i<n;i++) {
1153
                     dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1154
                     dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1155
                     dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1156
                  }
1157
                  break;
1158
               case GL_RGBA:
1159
                  for (i=0;i<n;i++) {
1160
                     dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1161
                     dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1162
                     dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1163
                     dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1164
                  }
1165
                  break;
1166
               case GL_BGR:
1167
                  for (i=0;i<n;i++) {
1168
                     dst[i*3+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1169
                     dst[i*3+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1170
                     dst[i*3+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1171
                  }
1172
                  break;
1173
               case GL_BGRA:
1174
                  for (i=0;i<n;i++) {
1175
                     dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1176
                     dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1177
                     dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1178
                     dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1179
                  }
1180
                  break;
1181
               case GL_ABGR_EXT:
1182
                  for (i=0;i<n;i++) {
1183
                     dst[i*4+0] = FLOAT_TO_USHORT(rgba[i][ACOMP]);
1184
                     dst[i*4+1] = FLOAT_TO_USHORT(rgba[i][BCOMP]);
1185
                     dst[i*4+2] = FLOAT_TO_USHORT(rgba[i][GCOMP]);
1186
                     dst[i*4+3] = FLOAT_TO_USHORT(rgba[i][RCOMP]);
1187
                  }
1188
                  break;
1189
               default:
1190
                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1191
            }
1192
            if (dstPacking->SwapBytes) {
1193
               _mesa_swap2( (GLushort *) dst, n * comps);
1194
            }
1195
         }
1196
         break;
1197
      case GL_SHORT:
1198
         {
1199
            GLshort *dst = (GLshort *) dstAddr;
1200
            switch (dstFormat) {
1201
               case GL_RED:
1202
                  for (i=0;i<n;i++)
1203
                     dst[i] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1204
                  break;
1205
               case GL_GREEN:
1206
                  for (i=0;i<n;i++)
1207
                     dst[i] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1208
                  break;
1209
               case GL_BLUE:
1210
                  for (i=0;i<n;i++)
1211
                     dst[i] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1212
                  break;
1213
               case GL_ALPHA:
1214
                  for (i=0;i<n;i++)
1215
                     dst[i] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1216
                  break;
1217
               case GL_LUMINANCE:
1218
                  for (i=0;i<n;i++)
1219
                     dst[i] = FLOAT_TO_SHORT(luminance[i]);
1220
                  break;
1221
               case GL_LUMINANCE_ALPHA:
1222
                  for (i=0;i<n;i++) {
1223
                     dst[i*2+0] = FLOAT_TO_SHORT(luminance[i]);
1224
                     dst[i*2+1] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1225
                  }
1226
                  break;
1227
               case GL_RGB:
1228
                  for (i=0;i<n;i++) {
1229
                     dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1230
                     dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1231
                     dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1232
                  }
1233
                  break;
1234
               case GL_RGBA:
1235
                  for (i=0;i<n;i++) {
1236
                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1237
                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1238
                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1239
                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1240
                  }
1241
                  break;
1242
               case GL_BGR:
1243
                  for (i=0;i<n;i++) {
1244
                     dst[i*3+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1245
                     dst[i*3+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1246
                     dst[i*3+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1247
                  }
1248
                  break;
1249
               case GL_BGRA:
1250
                  for (i=0;i<n;i++) {
1251
                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1252
                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1253
                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1254
                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1255
                  }
1256
               case GL_ABGR_EXT:
1257
                  for (i=0;i<n;i++) {
1258
                     dst[i*4+0] = FLOAT_TO_SHORT(rgba[i][ACOMP]);
1259
                     dst[i*4+1] = FLOAT_TO_SHORT(rgba[i][BCOMP]);
1260
                     dst[i*4+2] = FLOAT_TO_SHORT(rgba[i][GCOMP]);
1261
                     dst[i*4+3] = FLOAT_TO_SHORT(rgba[i][RCOMP]);
1262
                  }
1263
                  break;
1264
               default:
1265
                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1266
            }
1267
            if (dstPacking->SwapBytes) {
1268
               _mesa_swap2( (GLushort *) dst, n * comps );
1269
            }
1270
         }
1271
         break;
1272
      case GL_UNSIGNED_INT:
1273
         {
1274
            GLuint *dst = (GLuint *) dstAddr;
1275
            switch (dstFormat) {
1276
               case GL_RED:
1277
                  for (i=0;i<n;i++)
1278
                     dst[i] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1279
                  break;
1280
               case GL_GREEN:
1281
                  for (i=0;i<n;i++)
1282
                     dst[i] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1283
                  break;
1284
               case GL_BLUE:
1285
                  for (i=0;i<n;i++)
1286
                     dst[i] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1287
                  break;
1288
               case GL_ALPHA:
1289
                  for (i=0;i<n;i++)
1290
                     dst[i] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1291
                  break;
1292
               case GL_LUMINANCE:
1293
                  for (i=0;i<n;i++)
1294
                     dst[i] = FLOAT_TO_UINT(luminance[i]);
1295
                  break;
1296
               case GL_LUMINANCE_ALPHA:
1297
                  for (i=0;i<n;i++) {
1298
                     dst[i*2+0] = FLOAT_TO_UINT(luminance[i]);
1299
                     dst[i*2+1] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1300
                  }
1301
                  break;
1302
               case GL_RGB:
1303
                  for (i=0;i<n;i++) {
1304
                     dst[i*3+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1305
                     dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1306
                     dst[i*3+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1307
                  }
1308
                  break;
1309
               case GL_RGBA:
1310
                  for (i=0;i<n;i++) {
1311
                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1312
                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1313
                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1314
                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1315
                  }
1316
                  break;
1317
               case GL_BGR:
1318
                  for (i=0;i<n;i++) {
1319
                     dst[i*3+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1320
                     dst[i*3+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1321
                     dst[i*3+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1322
                  }
1323
                  break;
1324
               case GL_BGRA:
1325
                  for (i=0;i<n;i++) {
1326
                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1327
                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1328
                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1329
                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1330
                  }
1331
                  break;
1332
               case GL_ABGR_EXT:
1333
                  for (i=0;i<n;i++) {
1334
                     dst[i*4+0] = FLOAT_TO_UINT(rgba[i][ACOMP]);
1335
                     dst[i*4+1] = FLOAT_TO_UINT(rgba[i][BCOMP]);
1336
                     dst[i*4+2] = FLOAT_TO_UINT(rgba[i][GCOMP]);
1337
                     dst[i*4+3] = FLOAT_TO_UINT(rgba[i][RCOMP]);
1338
                  }
1339
                  break;
1340
               default:
1341
                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1342
            }
1343
            if (dstPacking->SwapBytes) {
1344
               _mesa_swap4( (GLuint *) dst, n * comps );
1345
            }
1346
         }
1347
         break;
1348
      case GL_INT:
1349
         {
1350
            GLint *dst = (GLint *) dstAddr;
1351
            switch (dstFormat) {
1352
               case GL_RED:
1353
                  for (i=0;i<n;i++)
1354
                     dst[i] = FLOAT_TO_INT(rgba[i][RCOMP]);
1355
                  break;
1356
               case GL_GREEN:
1357
                  for (i=0;i<n;i++)
1358
                     dst[i] = FLOAT_TO_INT(rgba[i][GCOMP]);
1359
                  break;
1360
               case GL_BLUE:
1361
                  for (i=0;i<n;i++)
1362
                     dst[i] = FLOAT_TO_INT(rgba[i][BCOMP]);
1363
                  break;
1364
               case GL_ALPHA:
1365
                  for (i=0;i<n;i++)
1366
                     dst[i] = FLOAT_TO_INT(rgba[i][ACOMP]);
1367
                  break;
1368
               case GL_LUMINANCE:
1369
                  for (i=0;i<n;i++)
1370
                     dst[i] = FLOAT_TO_INT(luminance[i]);
1371
                  break;
1372
               case GL_LUMINANCE_ALPHA:
1373
                  for (i=0;i<n;i++) {
1374
                     dst[i*2+0] = FLOAT_TO_INT(luminance[i]);
1375
                     dst[i*2+1] = FLOAT_TO_INT(rgba[i][ACOMP]);
1376
                  }
1377
                  break;
1378
               case GL_RGB:
1379
                  for (i=0;i<n;i++) {
1380
                     dst[i*3+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1381
                     dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1382
                     dst[i*3+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1383
                  }
1384
                  break;
1385
               case GL_RGBA:
1386
                  for (i=0;i<n;i++) {
1387
                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][RCOMP]);
1388
                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1389
                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][BCOMP]);
1390
                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1391
                  }
1392
                  break;
1393
               case GL_BGR:
1394
                  for (i=0;i<n;i++) {
1395
                     dst[i*3+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1396
                     dst[i*3+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1397
                     dst[i*3+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1398
                  }
1399
                  break;
1400
               case GL_BGRA:
1401
                  for (i=0;i<n;i++) {
1402
                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][BCOMP]);
1403
                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][GCOMP]);
1404
                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][RCOMP]);
1405
                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][ACOMP]);
1406
                  }
1407
                  break;
1408
               case GL_ABGR_EXT:
1409
                  for (i=0;i<n;i++) {
1410
                     dst[i*4+0] = FLOAT_TO_INT(rgba[i][ACOMP]);
1411
                     dst[i*4+1] = FLOAT_TO_INT(rgba[i][BCOMP]);
1412
                     dst[i*4+2] = FLOAT_TO_INT(rgba[i][GCOMP]);
1413
                     dst[i*4+3] = FLOAT_TO_INT(rgba[i][RCOMP]);
1414
                  }
1415
                  break;
1416
               default:
1417
                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1418
            }
1419
            if (dstPacking->SwapBytes) {
1420
               _mesa_swap4( (GLuint *) dst, n * comps );
1421
            }
1422
         }
1423
         break;
1424
      case GL_FLOAT:
1425
         {
1426
            GLfloat *dst = (GLfloat *) dstAddr;
1427
            switch (dstFormat) {
1428
               case GL_RED:
1429
                  for (i=0;i<n;i++)
1430
                     dst[i] = rgba[i][RCOMP];
1431
                  break;
1432
               case GL_GREEN:
1433
                  for (i=0;i<n;i++)
1434
                     dst[i] = rgba[i][GCOMP];
1435
                  break;
1436
               case GL_BLUE:
1437
                  for (i=0;i<n;i++)
1438
                     dst[i] = rgba[i][BCOMP];
1439
                  break;
1440
               case GL_ALPHA:
1441
                  for (i=0;i<n;i++)
1442
                     dst[i] = rgba[i][ACOMP];
1443
                  break;
1444
               case GL_LUMINANCE:
1445
                  for (i=0;i<n;i++)
1446
                     dst[i] = luminance[i];
1447
                  break;
1448
               case GL_LUMINANCE_ALPHA:
1449
                  for (i=0;i<n;i++) {
1450
                     dst[i*2+0] = luminance[i];
1451
                     dst[i*2+1] = rgba[i][ACOMP];
1452
                  }
1453
                  break;
1454
               case GL_RGB:
1455
                  for (i=0;i<n;i++) {
1456
                     dst[i*3+0] = rgba[i][RCOMP];
1457
                     dst[i*3+1] = rgba[i][GCOMP];
1458
                     dst[i*3+2] = rgba[i][BCOMP];
1459
                  }
1460
                  break;
1461
               case GL_RGBA:
1462
                  for (i=0;i<n;i++) {
1463
                     dst[i*4+0] = rgba[i][RCOMP];
1464
                     dst[i*4+1] = rgba[i][GCOMP];
1465
                     dst[i*4+2] = rgba[i][BCOMP];
1466
                     dst[i*4+3] = rgba[i][ACOMP];
1467
                  }
1468
                  break;
1469
               case GL_BGR:
1470
                  for (i=0;i<n;i++) {
1471
                     dst[i*3+0] = rgba[i][BCOMP];
1472
                     dst[i*3+1] = rgba[i][GCOMP];
1473
                     dst[i*3+2] = rgba[i][RCOMP];
1474
                  }
1475
                  break;
1476
               case GL_BGRA:
1477
                  for (i=0;i<n;i++) {
1478
                     dst[i*4+0] = rgba[i][BCOMP];
1479
                     dst[i*4+1] = rgba[i][GCOMP];
1480
                     dst[i*4+2] = rgba[i][RCOMP];
1481
                     dst[i*4+3] = rgba[i][ACOMP];
1482
                  }
1483
                  break;
1484
               case GL_ABGR_EXT:
1485
                  for (i=0;i<n;i++) {
1486
                     dst[i*4+0] = rgba[i][ACOMP];
1487
                     dst[i*4+1] = rgba[i][BCOMP];
1488
                     dst[i*4+2] = rgba[i][GCOMP];
1489
                     dst[i*4+3] = rgba[i][RCOMP];
1490
                  }
1491
                  break;
1492
               default:
1493
                  _mesa_problem(ctx, "bad format in _mesa_pack_rgba_span\n");
1494
            }
1495
            if (dstPacking->SwapBytes) {
1496
               _mesa_swap4( (GLuint *) dst, n * comps );
1497
            }
1498
         }
1499
         break;
1500
      case GL_UNSIGNED_BYTE_3_3_2:
1501
         if (dstFormat == GL_RGB) {
1502
            GLubyte *dst = (GLubyte *) dstAddr;
1503
            for (i=0;i<n;i++) {
1504
               dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F)) << 5)
1505
                      | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 2)
1506
                      | (((GLint) (rgba[i][BCOMP] * 3.0F))     );
1507
            }
1508
         }
1509
         break;
1510
      case GL_UNSIGNED_BYTE_2_3_3_REV:
1511
         if (dstFormat == GL_RGB) {
1512
            GLubyte *dst = (GLubyte *) dstAddr;
1513
            for (i=0;i<n;i++) {
1514
               dst[i] = (((GLint) (rgba[i][RCOMP] * 7.0F))     )
1515
                      | (((GLint) (rgba[i][GCOMP] * 7.0F)) << 3)
1516
                      | (((GLint) (rgba[i][BCOMP] * 3.0F)) << 5);
1517
            }
1518
         }
1519
         break;
1520
      case GL_UNSIGNED_SHORT_5_6_5:
1521
         if (dstFormat == GL_RGB) {
1522
            GLushort *dst = (GLushort *) dstAddr;
1523
            for (i=0;i<n;i++) {
1524
               dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1525
                      | (((GLint) (rgba[i][GCOMP] * 63.0F)) <<  5)
1526
                      | (((GLint) (rgba[i][BCOMP] * 31.0F))      );
1527
            }
1528
         }
1529
         break;
1530
      case GL_UNSIGNED_SHORT_5_6_5_REV:
1531
         if (dstFormat == GL_RGB) {
1532
            GLushort *dst = (GLushort *) dstAddr;
1533
            for (i=0;i<n;i++) {
1534
               dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F))      )
1535
                      | (((GLint) (rgba[i][GCOMP] * 63.0F)) <<  5)
1536
                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11);
1537
            }
1538
         }
1539
         break;
1540
      case GL_UNSIGNED_SHORT_4_4_4_4:
1541
         if (dstFormat == GL_RGBA) {
1542
            GLushort *dst = (GLushort *) dstAddr;
1543
            for (i=0;i<n;i++) {
1544
               dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12)
1545
                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
1546
                      | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  4)
1547
                      | (((GLint) (rgba[i][ACOMP] * 15.0F))      );
1548
            }
1549
         }
1550
         else if (dstFormat == GL_BGRA) {
1551
            GLushort *dst = (GLushort *) dstAddr;
1552
            for (i=0;i<n;i++) {
1553
               dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F)) << 12)
1554
                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
1555
                      | (((GLint) (rgba[i][RCOMP] * 15.0F)) <<  4)
1556
                      | (((GLint) (rgba[i][ACOMP] * 15.0F))      );
1557
            }
1558
         }
1559
         else if (dstFormat == GL_ABGR_EXT) {
1560
            GLushort *dst = (GLushort *) dstAddr;
1561
            for (i=0;i<n;i++) {
1562
               dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F)) <<  4)
1563
                      | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  8)
1564
                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) << 12)
1565
                      | (((GLint) (rgba[i][RCOMP] * 15.0F))      );
1566
            }
1567
         }
1568
         break;
1569
      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
1570
         if (dstFormat == GL_RGBA) {
1571
            GLushort *dst = (GLushort *) dstAddr;
1572
            for (i=0;i<n;i++) {
1573
               dst[i] = (((GLint) (rgba[i][RCOMP] * 15.0F))      )
1574
                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
1575
                      | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  8)
1576
                      | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1577
            }
1578
         }
1579
         else if (dstFormat == GL_BGRA) {
1580
            GLushort *dst = (GLushort *) dstAddr;
1581
            for (i=0;i<n;i++) {
1582
               dst[i] = (((GLint) (rgba[i][BCOMP] * 15.0F))      )
1583
                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  4)
1584
                      | (((GLint) (rgba[i][RCOMP] * 15.0F)) <<  8)
1585
                      | (((GLint) (rgba[i][ACOMP] * 15.0F)) << 12);
1586
            }
1587
         }
1588
         else if (dstFormat == GL_ABGR_EXT) {
1589
            GLushort *dst = (GLushort *) dstAddr;
1590
            for (i=0;i<n;i++) {
1591
               dst[i] = (((GLint) (rgba[i][ACOMP] * 15.0F))      )
1592
                      | (((GLint) (rgba[i][BCOMP] * 15.0F)) <<  4)
1593
                      | (((GLint) (rgba[i][GCOMP] * 15.0F)) <<  8)
1594
                      | (((GLint) (rgba[i][RCOMP] * 15.0F)) << 12);
1595
            }
1596
         }
1597
         break;
1598
      case GL_UNSIGNED_SHORT_5_5_5_1:
1599
         if (dstFormat == GL_RGBA) {
1600
            GLushort *dst = (GLushort *) dstAddr;
1601
            for (i=0;i<n;i++) {
1602
               dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F)) << 11)
1603
                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  6)
1604
                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  1)
1605
                      | (((GLint) (rgba[i][ACOMP] *  1.0F))      );
1606
            }
1607
         }
1608
         else if (dstFormat == GL_BGRA) {
1609
            GLushort *dst = (GLushort *) dstAddr;
1610
            for (i=0;i<n;i++) {
1611
               dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F)) << 11)
1612
                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  6)
1613
                      | (((GLint) (rgba[i][RCOMP] * 31.0F)) <<  1)
1614
                      | (((GLint) (rgba[i][ACOMP] *  1.0F))      );
1615
            }
1616
         }
1617
         else if (dstFormat == GL_ABGR_EXT) {
1618
            GLushort *dst = (GLushort *) dstAddr;
1619
            for (i=0;i<n;i++) {
1620
               dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F)) << 11)
1621
                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  6)
1622
                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  1)
1623
                      | (((GLint) (rgba[i][RCOMP] *  1.0F))      );
1624
            }
1625
         }
1626
         break;
1627
      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
1628
         if (dstFormat == GL_RGBA) {
1629
            GLushort *dst = (GLushort *) dstAddr;
1630
            for (i=0;i<n;i++) {
1631
               dst[i] = (((GLint) (rgba[i][RCOMP] * 31.0F))      )
1632
                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  5)
1633
                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) << 10)
1634
                      | (((GLint) (rgba[i][ACOMP] *  1.0F)) << 15);
1635
            }
1636
         }
1637
         else if (dstFormat == GL_BGRA) {
1638
            GLushort *dst = (GLushort *) dstAddr;
1639
            for (i=0;i<n;i++) {
1640
               dst[i] = (((GLint) (rgba[i][BCOMP] * 31.0F))      )
1641
                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) <<  5)
1642
                      | (((GLint) (rgba[i][RCOMP] * 31.0F)) << 10)
1643
                      | (((GLint) (rgba[i][ACOMP] *  1.0F)) << 15);
1644
            }
1645
         }
1646
         else if (dstFormat == GL_ABGR_EXT) {
1647
            GLushort *dst = (GLushort *) dstAddr;
1648
            for (i=0;i<n;i++) {
1649
               dst[i] = (((GLint) (rgba[i][ACOMP] * 31.0F))      )
1650
                      | (((GLint) (rgba[i][BCOMP] * 31.0F)) <<  5)
1651
                      | (((GLint) (rgba[i][GCOMP] * 31.0F)) << 10)
1652
                      | (((GLint) (rgba[i][RCOMP] *  1.0F)) << 15);
1653
            }
1654
         }
1655
         break;
1656
      case GL_UNSIGNED_INT_8_8_8_8:
1657
         if (dstFormat == GL_RGBA) {
1658
            GLuint *dst = (GLuint *) dstAddr;
1659
            for (i=0;i<n;i++) {
1660
               dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24)
1661
                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1662
                      | (((GLuint) (rgba[i][BCOMP] * 255.0F)) <<  8)
1663
                      | (((GLuint) (rgba[i][ACOMP] * 255.0F))      );
1664
            }
1665
         }
1666
         else if (dstFormat == GL_BGRA) {
1667
            GLuint *dst = (GLuint *) dstAddr;
1668
            for (i=0;i<n;i++) {
1669
               dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 24)
1670
                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1671
                      | (((GLuint) (rgba[i][RCOMP] * 255.0F)) <<  8)
1672
                      | (((GLuint) (rgba[i][ACOMP] * 255.0F))      );
1673
            }
1674
         }
1675
         else if (dstFormat == GL_ABGR_EXT) {
1676
            GLuint *dst = (GLuint *) dstAddr;
1677
            for (i=0;i<n;i++) {
1678
               dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24)
1679
                      | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1680
                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
1681
                      | (((GLuint) (rgba[i][RCOMP] * 255.0F))      );
1682
            }
1683
         }
1684
         break;
1685
      case GL_UNSIGNED_INT_8_8_8_8_REV:
1686
         if (dstFormat == GL_RGBA) {
1687
            GLuint *dst = (GLuint *) dstAddr;
1688
            for (i=0;i<n;i++) {
1689
               dst[i] = (((GLuint) (rgba[i][RCOMP] * 255.0F))      )
1690
                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
1691
                      | (((GLuint) (rgba[i][BCOMP] * 255.0F)) << 16)
1692
                      | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1693
            }
1694
         }
1695
         else if (dstFormat == GL_BGRA) {
1696
            GLuint *dst = (GLuint *) dstAddr;
1697
            for (i=0;i<n;i++) {
1698
               dst[i] = (((GLuint) (rgba[i][BCOMP] * 255.0F))      )
1699
                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) <<  8)
1700
                      | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 16)
1701
                      | (((GLuint) (rgba[i][ACOMP] * 255.0F)) << 24);
1702
            }
1703
         }
1704
         else if (dstFormat == GL_ABGR_EXT) {
1705
            GLuint *dst = (GLuint *) dstAddr;
1706
            for (i=0;i<n;i++) {
1707
               dst[i] = (((GLuint) (rgba[i][ACOMP] * 255.0F))      )
1708
                      | (((GLuint) (rgba[i][BCOMP] * 255.0F)) <<  8)
1709
                      | (((GLuint) (rgba[i][GCOMP] * 255.0F)) << 16)
1710
                      | (((GLuint) (rgba[i][RCOMP] * 255.0F)) << 24);
1711
            }
1712
         }
1713
         break;
1714
      case GL_UNSIGNED_INT_10_10_10_2:
1715
         if (dstFormat == GL_RGBA) {
1716
            GLuint *dst = (GLuint *) dstAddr;
1717
            for (i=0;i<n;i++) {
1718
               dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 22)
1719
                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
1720
                      | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) <<  2)
1721
                      | (((GLuint) (rgba[i][ACOMP] *    3.0F))      );
1722
            }
1723
         }
1724
         else if (dstFormat == GL_BGRA) {
1725
            GLuint *dst = (GLuint *) dstAddr;
1726
            for (i=0;i<n;i++) {
1727
               dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 22)
1728
                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 12)
1729
                      | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) <<  2)
1730
                      | (((GLuint) (rgba[i][ACOMP] *    3.0F))      );
1731
            }
1732
         }
1733
         else if (dstFormat == GL_ABGR_EXT) {
1734
            GLuint *dst = (GLuint *) dstAddr;
1735
            for (i=0;i<n;i++) {
1736
               dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F)) << 22)
1737
                      | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 12)
1738
                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) <<  2)
1739
                      | (((GLuint) (rgba[i][RCOMP] *    3.0F))      );
1740
            }
1741
         }
1742
         break;
1743
      case GL_UNSIGNED_INT_2_10_10_10_REV:
1744
         if (dstFormat == GL_RGBA) {
1745
            GLuint *dst = (GLuint *) dstAddr;
1746
            for (i=0;i<n;i++) {
1747
               dst[i] = (((GLuint) (rgba[i][RCOMP] * 1023.0F))      )
1748
                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
1749
                      | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 20)
1750
                      | (((GLuint) (rgba[i][ACOMP] *    3.0F)) << 30);
1751
            }
1752
         }
1753
         else if (dstFormat == GL_BGRA) {
1754
            GLuint *dst = (GLuint *) dstAddr;
1755
            for (i=0;i<n;i++) {
1756
               dst[i] = (((GLuint) (rgba[i][BCOMP] * 1023.0F))      )
1757
                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 10)
1758
                      | (((GLuint) (rgba[i][RCOMP] * 1023.0F)) << 20)
1759
                      | (((GLuint) (rgba[i][ACOMP] *    3.0F)) << 30);
1760
            }
1761
         }
1762
         else if (dstFormat == GL_ABGR_EXT) {
1763
            GLuint *dst = (GLuint *) dstAddr;
1764
            for (i=0;i<n;i++) {
1765
               dst[i] = (((GLuint) (rgba[i][ACOMP] * 1023.0F))      )
1766
                      | (((GLuint) (rgba[i][BCOMP] * 1023.0F)) << 10)
1767
                      | (((GLuint) (rgba[i][GCOMP] * 1023.0F)) << 20)
1768
                      | (((GLuint) (rgba[i][RCOMP] *    3.0F)) << 30);
1769
            }
1770
         }
1771
         break;
1772
      default:
1773
         _mesa_problem(ctx, "bad type in _mesa_pack_float_rgba_span");
1774
   }
1775
}
1776
 
1777
 
1778
 
1779
/*
1780
 * Pack the given RGBA span into client memory at 'dest' address
1781
 * in the given pixel format and type.
1782
 * Optionally apply the enabled pixel transfer ops.
1783
 * Pack into memory using the given packing params struct.
1784
 * This is used by glReadPixels and glGetTexImage?D()
1785
 * Input:  ctx - the context
1786
 *         n - number of pixels in the span
1787
 *         rgba - the pixels
1788
 *         format - dest packing format
1789
 *         type - dest packing datatype
1790
 *         destination - destination packing address
1791
 *         packing - pixel packing parameters
1792
 *         transferOps - bitmask of IMAGE_*_BIT operations to apply
1793
 */
1794
void
1795
_mesa_pack_rgba_span( GLcontext *ctx,
1796
                      GLuint n, CONST GLchan srcRgba[][4],
1797
                      GLenum dstFormat, GLenum dstType,
1798
                      GLvoid *dstAddr,
1799
                      const struct gl_pixelstore_attrib *dstPacking,
1800
                      GLuint transferOps)
1801
{
1802
   ASSERT((ctx->NewState & _NEW_PIXEL) == 0 || transferOps == 0);
1803
 
1804
   /* Test for optimized case first */
1805
   if (transferOps == 0 && dstFormat == GL_RGBA && dstType == CHAN_TYPE) {
1806
      /* common simple case */
1807
      MEMCPY(dstAddr, srcRgba, n * 4 * sizeof(GLchan));
1808
   }
1809
   else if (transferOps == 0 && dstFormat == GL_RGB && dstType == CHAN_TYPE) {
1810
      /* common simple case */
1811
      GLuint i;
1812
      GLchan *dest = (GLchan *) dstAddr;
1813
      for (i = 0; i < n; i++) {
1814
         dest[0] = srcRgba[i][RCOMP];
1815
         dest[1] = srcRgba[i][GCOMP];
1816
         dest[2] = srcRgba[i][BCOMP];
1817
         dest += 3;
1818
      }
1819
   }
1820
   else if (transferOps == 0 && dstFormat == GL_RGBA && dstType == GL_UNSIGNED_BYTE) {
1821
      /* common simple case */
1822
      GLuint i;
1823
      GLubyte *dest = (GLubyte *) dstAddr;
1824
      for (i = 0; i < n; i++) {
1825
         dest[0] = CHAN_TO_UBYTE(srcRgba[i][RCOMP]);
1826
         dest[1] = CHAN_TO_UBYTE(srcRgba[i][GCOMP]);
1827
         dest[2] = CHAN_TO_UBYTE(srcRgba[i][BCOMP]);
1828
         dest[3] = CHAN_TO_UBYTE(srcRgba[i][ACOMP]);
1829
         dest += 4;
1830
      }
1831
   }
1832
   else {
1833
      /* general solution */
1834
      GLuint i;
1835
      DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
1836
      CHECKARRAY(rgba, return);  /* mac 32k limitation */
1837
 
1838
      assert(n <= MAX_WIDTH);
1839
      /* convert color components to floating point */
1840
      for (i=0;i<n;i++) {
1841
         rgba[i][RCOMP] = CHAN_TO_FLOAT(srcRgba[i][RCOMP]);
1842
         rgba[i][GCOMP] = CHAN_TO_FLOAT(srcRgba[i][GCOMP]);
1843
         rgba[i][BCOMP] = CHAN_TO_FLOAT(srcRgba[i][BCOMP]);
1844
         rgba[i][ACOMP] = CHAN_TO_FLOAT(srcRgba[i][ACOMP]);
1845
      }
1846
      _mesa_pack_float_rgba_span(ctx, n, (const GLfloat (*)[4]) rgba,
1847
                                 dstFormat, dstType, dstAddr,
1848
                                 dstPacking, transferOps);
1849
      UNDEFARRAY(rgba);  /* mac 32k limitation */
1850
   }
1851
}
1852
 
1853
 
1854
#define SWAP2BYTE(VALUE)                        \
1855
   {                                            \
1856
      GLubyte *bytes = (GLubyte *) &(VALUE);    \
1857
      GLubyte tmp = bytes[0];                   \
1858
      bytes[0] = bytes[1];                      \
1859
      bytes[1] = tmp;                           \
1860
   }
1861
 
1862
#define SWAP4BYTE(VALUE)                        \
1863
   {                                            \
1864
      GLubyte *bytes = (GLubyte *) &(VALUE);    \
1865
      GLubyte tmp = bytes[0];                   \
1866
      bytes[0] = bytes[3];                      \
1867
      bytes[3] = tmp;                           \
1868
      tmp = bytes[1];                           \
1869
      bytes[1] = bytes[2];                      \
1870
      bytes[2] = tmp;                           \
1871
   }
1872
 
1873
 
1874
static void
1875
extract_uint_indexes(GLuint n, GLuint indexes[],
1876
                     GLenum srcFormat, GLenum srcType, const GLvoid *src,
1877
                     const struct gl_pixelstore_attrib *unpack )
1878
{
1879
   assert(srcFormat == GL_COLOR_INDEX);
1880
 
1881
   ASSERT(srcType == GL_BITMAP ||
1882
          srcType == GL_UNSIGNED_BYTE ||
1883
          srcType == GL_BYTE ||
1884
          srcType == GL_UNSIGNED_SHORT ||
1885
          srcType == GL_SHORT ||
1886
          srcType == GL_UNSIGNED_INT ||
1887
          srcType == GL_INT ||
1888
          srcType == GL_FLOAT);
1889
 
1890
   switch (srcType) {
1891
      case GL_BITMAP:
1892
         {
1893
            GLubyte *ubsrc = (GLubyte *) src;
1894
            if (unpack->LsbFirst) {
1895
               GLubyte mask = 1 << (unpack->SkipPixels & 0x7);
1896
               GLuint i;
1897
               for (i = 0; i < n; i++) {
1898
                  indexes[i] = (*ubsrc & mask) ? 1 : 0;
1899
                  if (mask == 128) {
1900
                     mask = 1;
1901
                     ubsrc++;
1902
                  }
1903
                  else {
1904
                     mask = mask << 1;
1905
                  }
1906
               }
1907
            }
1908
            else {
1909
               GLubyte mask = 128 >> (unpack->SkipPixels & 0x7);
1910
               GLuint i;
1911
               for (i = 0; i < n; i++) {
1912
                  indexes[i] = (*ubsrc & mask) ? 1 : 0;
1913
                  if (mask == 1) {
1914
                     mask = 128;
1915
                     ubsrc++;
1916
                  }
1917
                  else {
1918
                     mask = mask >> 1;
1919
                  }
1920
               }
1921
            }
1922
         }
1923
         break;
1924
      case GL_UNSIGNED_BYTE:
1925
         {
1926
            GLuint i;
1927
            const GLubyte *s = (const GLubyte *) src;
1928
            for (i = 0; i < n; i++)
1929
               indexes[i] = s[i];
1930
         }
1931
         break;
1932
      case GL_BYTE:
1933
         {
1934
            GLuint i;
1935
            const GLbyte *s = (const GLbyte *) src;
1936
            for (i = 0; i < n; i++)
1937
               indexes[i] = s[i];
1938
         }
1939
         break;
1940
      case GL_UNSIGNED_SHORT:
1941
         {
1942
            GLuint i;
1943
            const GLushort *s = (const GLushort *) src;
1944
            if (unpack->SwapBytes) {
1945
               for (i = 0; i < n; i++) {
1946
                  GLushort value = s[i];
1947
                  SWAP2BYTE(value);
1948
                  indexes[i] = value;
1949
               }
1950
            }
1951
            else {
1952
               for (i = 0; i < n; i++)
1953
                  indexes[i] = s[i];
1954
            }
1955
         }
1956
         break;
1957
      case GL_SHORT:
1958
         {
1959
            GLuint i;
1960
            const GLshort *s = (const GLshort *) src;
1961
            if (unpack->SwapBytes) {
1962
               for (i = 0; i < n; i++) {
1963
                  GLshort value = s[i];
1964
                  SWAP2BYTE(value);
1965
                  indexes[i] = value;
1966
               }
1967
            }
1968
            else {
1969
               for (i = 0; i < n; i++)
1970
                  indexes[i] = s[i];
1971
            }
1972
         }
1973
         break;
1974
      case GL_UNSIGNED_INT:
1975
         {
1976
            GLuint i;
1977
            const GLuint *s = (const GLuint *) src;
1978
            if (unpack->SwapBytes) {
1979
               for (i = 0; i < n; i++) {
1980
                  GLuint value = s[i];
1981
                  SWAP4BYTE(value);
1982
                  indexes[i] = value;
1983
               }
1984
            }
1985
            else {
1986
               for (i = 0; i < n; i++)
1987
                  indexes[i] = s[i];
1988
            }
1989
         }
1990
         break;
1991
      case GL_INT:
1992
         {
1993
            GLuint i;
1994
            const GLint *s = (const GLint *) src;
1995
            if (unpack->SwapBytes) {
1996
               for (i = 0; i < n; i++) {
1997
                  GLint value = s[i];
1998
                  SWAP4BYTE(value);
1999
                  indexes[i] = value;
2000
               }
2001
            }
2002
            else {
2003
               for (i = 0; i < n; i++)
2004
                  indexes[i] = s[i];
2005
            }
2006
         }
2007
         break;
2008
      case GL_FLOAT:
2009
         {
2010
            GLuint i;
2011
            const GLfloat *s = (const GLfloat *) src;
2012
            if (unpack->SwapBytes) {
2013
               for (i = 0; i < n; i++) {
2014
                  GLfloat value = s[i];
2015
                  SWAP4BYTE(value);
2016
                  indexes[i] = (GLuint) value;
2017
               }
2018
            }
2019
            else {
2020
               for (i = 0; i < n; i++)
2021
                  indexes[i] = (GLuint) s[i];
2022
            }
2023
         }
2024
         break;
2025
      default:
2026
         _mesa_problem(NULL, "bad srcType in extract_uint_indexes");
2027
         return;
2028
   }
2029
}
2030
 
2031
 
2032
 
2033
/*
2034
 * This function extracts floating point RGBA values from arbitrary
2035
 * image data.  srcFormat and srcType are the format and type parameters
2036
 * passed to glDrawPixels, glTexImage[123]D, glTexSubImage[123]D, etc.
2037
 *
2038
 * Refering to section 3.6.4 of the OpenGL 1.2 spec, this function
2039
 * implements the "Conversion to floating point", "Conversion to RGB",
2040
 * and "Final Expansion to RGBA" operations.
2041
 *
2042
 * Args:  n - number of pixels
2043
 *        rgba - output colors
2044
 *        srcFormat - format of incoming data
2045
 *        srcType - datatype of incoming data
2046
 *        src - source data pointer
2047
 *        swapBytes - perform byteswapping of incoming data?
2048
 */
2049
static void
2050
extract_float_rgba(GLuint n, GLfloat rgba[][4],
2051
                   GLenum srcFormat, GLenum srcType, const GLvoid *src,
2052
                   GLboolean swapBytes)
2053
{
2054
   GLint redIndex, greenIndex, blueIndex, alphaIndex;
2055
   GLint stride;
2056
   GLint rComp, bComp, gComp, aComp;
2057
 
2058
   ASSERT(srcFormat == GL_RED ||
2059
          srcFormat == GL_GREEN ||
2060
          srcFormat == GL_BLUE ||
2061
          srcFormat == GL_ALPHA ||
2062
          srcFormat == GL_LUMINANCE ||
2063
          srcFormat == GL_LUMINANCE_ALPHA ||
2064
          srcFormat == GL_INTENSITY ||
2065
          srcFormat == GL_RGB ||
2066
          srcFormat == GL_BGR ||
2067
          srcFormat == GL_RGBA ||
2068
          srcFormat == GL_BGRA ||
2069
          srcFormat == GL_ABGR_EXT);
2070
 
2071
   ASSERT(srcType == GL_UNSIGNED_BYTE ||
2072
          srcType == GL_BYTE ||
2073
          srcType == GL_UNSIGNED_SHORT ||
2074
          srcType == GL_SHORT ||
2075
          srcType == GL_UNSIGNED_INT ||
2076
          srcType == GL_INT ||
2077
          srcType == GL_FLOAT ||
2078
          srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2079
          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2080
          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2081
          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2082
          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2083
          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2084
          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2085
          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2086
          srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2087
          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2088
          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2089
          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2090
 
2091
   rComp = gComp = bComp = aComp = -1;
2092
 
2093
   switch (srcFormat) {
2094
      case GL_RED:
2095
         redIndex = 0;
2096
         greenIndex = blueIndex = alphaIndex = -1;
2097
         stride = 1;
2098
         break;
2099
      case GL_GREEN:
2100
         greenIndex = 0;
2101
         redIndex = blueIndex = alphaIndex = -1;
2102
         stride = 1;
2103
         break;
2104
      case GL_BLUE:
2105
         blueIndex = 0;
2106
         redIndex = greenIndex = alphaIndex = -1;
2107
         stride = 1;
2108
         break;
2109
      case GL_ALPHA:
2110
         redIndex = greenIndex = blueIndex = -1;
2111
         alphaIndex = 0;
2112
         stride = 1;
2113
         break;
2114
      case GL_LUMINANCE:
2115
         redIndex = greenIndex = blueIndex = 0;
2116
         alphaIndex = -1;
2117
         stride = 1;
2118
         break;
2119
      case GL_LUMINANCE_ALPHA:
2120
         redIndex = greenIndex = blueIndex = 0;
2121
         alphaIndex = 1;
2122
         stride = 2;
2123
         break;
2124
      case GL_INTENSITY:
2125
         redIndex = greenIndex = blueIndex = alphaIndex = 0;
2126
         stride = 1;
2127
         break;
2128
      case GL_RGB:
2129
         redIndex = 0;
2130
         greenIndex = 1;
2131
         blueIndex = 2;
2132
         alphaIndex = -1;
2133
         stride = 3;
2134
         break;
2135
      case GL_BGR:
2136
         redIndex = 2;
2137
         greenIndex = 1;
2138
         blueIndex = 0;
2139
         alphaIndex = -1;
2140
         stride = 3;
2141
         break;
2142
      case GL_RGBA:
2143
         redIndex = 0;
2144
         greenIndex = 1;
2145
         blueIndex = 2;
2146
         alphaIndex = 3;
2147
         rComp = 0;
2148
         gComp = 1;
2149
         bComp = 2;
2150
         aComp = 3;
2151
         stride = 4;
2152
         break;
2153
      case GL_BGRA:
2154
         redIndex = 2;
2155
         greenIndex = 1;
2156
         blueIndex = 0;
2157
         alphaIndex = 3;
2158
         rComp = 2;
2159
         gComp = 1;
2160
         bComp = 0;
2161
         aComp = 3;
2162
         stride = 4;
2163
         break;
2164
      case GL_ABGR_EXT:
2165
         redIndex = 3;
2166
         greenIndex = 2;
2167
         blueIndex = 1;
2168
         alphaIndex = 0;
2169
         rComp = 3;
2170
         gComp = 2;
2171
         bComp = 1;
2172
         aComp = 0;
2173
         stride = 4;
2174
         break;
2175
      default:
2176
         _mesa_problem(NULL, "bad srcFormat in extract float data");
2177
         return;
2178
   }
2179
 
2180
 
2181
#define PROCESS(INDEX, CHANNEL, DEFAULT, TYPE, CONVERSION)              \
2182
   if ((INDEX) < 0) {                                                   \
2183
      GLuint i;                                                         \
2184
      for (i = 0; i < n; i++) {                                         \
2185
         rgba[i][CHANNEL] = DEFAULT;                                    \
2186
      }                                                                 \
2187
   }                                                                    \
2188
   else if (swapBytes) {                                                \
2189
      const TYPE *s = (const TYPE *) src;                               \
2190
      GLuint i;                                                         \
2191
      for (i = 0; i < n; i++) {                                         \
2192
         TYPE value = s[INDEX];                                         \
2193
         if (sizeof(TYPE) == 2) {                                       \
2194
            SWAP2BYTE(value);                                           \
2195
         }                                                              \
2196
         else if (sizeof(TYPE) == 4) {                                  \
2197
            SWAP4BYTE(value);                                           \
2198
         }                                                              \
2199
         rgba[i][CHANNEL] = (GLfloat) CONVERSION(value);                \
2200
         s += stride;                                                   \
2201
      }                                                                 \
2202
   }                                                                    \
2203
   else {                                                               \
2204
      const TYPE *s = (const TYPE *) src;                               \
2205
      GLuint i;                                                         \
2206
      for (i = 0; i < n; i++) {                                         \
2207
         rgba[i][CHANNEL] = (GLfloat) CONVERSION(s[INDEX]);             \
2208
         s += stride;                                                   \
2209
      }                                                                 \
2210
   }
2211
 
2212
   switch (srcType) {
2213
      case GL_UNSIGNED_BYTE:
2214
         PROCESS(redIndex,   RCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2215
         PROCESS(greenIndex, GCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2216
         PROCESS(blueIndex,  BCOMP, 0.0F, GLubyte, UBYTE_TO_FLOAT);
2217
         PROCESS(alphaIndex, ACOMP, 1.0F, GLubyte, UBYTE_TO_FLOAT);
2218
         break;
2219
      case GL_BYTE:
2220
         PROCESS(redIndex,   RCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2221
         PROCESS(greenIndex, GCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2222
         PROCESS(blueIndex,  BCOMP, 0.0F, GLbyte, BYTE_TO_FLOAT);
2223
         PROCESS(alphaIndex, ACOMP, 1.0F, GLbyte, BYTE_TO_FLOAT);
2224
         break;
2225
      case GL_UNSIGNED_SHORT:
2226
         PROCESS(redIndex,   RCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2227
         PROCESS(greenIndex, GCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2228
         PROCESS(blueIndex,  BCOMP, 0.0F, GLushort, USHORT_TO_FLOAT);
2229
         PROCESS(alphaIndex, ACOMP, 1.0F, GLushort, USHORT_TO_FLOAT);
2230
         break;
2231
      case GL_SHORT:
2232
         PROCESS(redIndex,   RCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2233
         PROCESS(greenIndex, GCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2234
         PROCESS(blueIndex,  BCOMP, 0.0F, GLshort, SHORT_TO_FLOAT);
2235
         PROCESS(alphaIndex, ACOMP, 1.0F, GLshort, SHORT_TO_FLOAT);
2236
         break;
2237
      case GL_UNSIGNED_INT:
2238
         PROCESS(redIndex,   RCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2239
         PROCESS(greenIndex, GCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2240
         PROCESS(blueIndex,  BCOMP, 0.0F, GLuint, UINT_TO_FLOAT);
2241
         PROCESS(alphaIndex, ACOMP, 1.0F, GLuint, UINT_TO_FLOAT);
2242
         break;
2243
      case GL_INT:
2244
         PROCESS(redIndex,   RCOMP, 0.0F, GLint, INT_TO_FLOAT);
2245
         PROCESS(greenIndex, GCOMP, 0.0F, GLint, INT_TO_FLOAT);
2246
         PROCESS(blueIndex,  BCOMP, 0.0F, GLint, INT_TO_FLOAT);
2247
         PROCESS(alphaIndex, ACOMP, 1.0F, GLint, INT_TO_FLOAT);
2248
         break;
2249
      case GL_FLOAT:
2250
         PROCESS(redIndex,   RCOMP, 0.0F, GLfloat, (GLfloat));
2251
         PROCESS(greenIndex, GCOMP, 0.0F, GLfloat, (GLfloat));
2252
         PROCESS(blueIndex,  BCOMP, 0.0F, GLfloat, (GLfloat));
2253
         PROCESS(alphaIndex, ACOMP, 1.0F, GLfloat, (GLfloat));
2254
         break;
2255
      case GL_UNSIGNED_BYTE_3_3_2:
2256
         {
2257
            const GLubyte *ubsrc = (const GLubyte *) src;
2258
            GLuint i;
2259
            for (i = 0; i < n; i ++) {
2260
               GLubyte p = ubsrc[i];
2261
               rgba[i][RCOMP] = ((p >> 5)      ) * (1.0F / 7.0F);
2262
               rgba[i][GCOMP] = ((p >> 2) & 0x7) * (1.0F / 7.0F);
2263
               rgba[i][BCOMP] = ((p     ) & 0x3) * (1.0F / 3.0F);
2264
               rgba[i][ACOMP] = 1.0F;
2265
            }
2266
         }
2267
         break;
2268
      case GL_UNSIGNED_BYTE_2_3_3_REV:
2269
         {
2270
            const GLubyte *ubsrc = (const GLubyte *) src;
2271
            GLuint i;
2272
            for (i = 0; i < n; i ++) {
2273
               GLubyte p = ubsrc[i];
2274
               rgba[i][RCOMP] = ((p     ) & 0x7) * (1.0F / 7.0F);
2275
               rgba[i][GCOMP] = ((p >> 3) & 0x7) * (1.0F / 7.0F);
2276
               rgba[i][BCOMP] = ((p >> 6)      ) * (1.0F / 3.0F);
2277
               rgba[i][ACOMP] = 1.0F;
2278
            }
2279
         }
2280
         break;
2281
      case GL_UNSIGNED_SHORT_5_6_5:
2282
         if (swapBytes) {
2283
            const GLushort *ussrc = (const GLushort *) src;
2284
            GLuint i;
2285
            for (i = 0; i < n; i ++) {
2286
               GLushort p = ussrc[i];
2287
               SWAP2BYTE(p);
2288
               rgba[i][RCOMP] = ((p >> 11)       ) * (1.0F / 31.0F);
2289
               rgba[i][GCOMP] = ((p >>  5) & 0x3f) * (1.0F / 63.0F);
2290
               rgba[i][BCOMP] = ((p      ) & 0x1f) * (1.0F / 31.0F);
2291
               rgba[i][ACOMP] = 1.0F;
2292
            }
2293
         }
2294
         else {
2295
            const GLushort *ussrc = (const GLushort *) src;
2296
            GLuint i;
2297
            for (i = 0; i < n; i ++) {
2298
               GLushort p = ussrc[i];
2299
               rgba[i][RCOMP] = ((p >> 11)       ) * (1.0F / 31.0F);
2300
               rgba[i][GCOMP] = ((p >>  5) & 0x3f) * (1.0F / 63.0F);
2301
               rgba[i][BCOMP] = ((p      ) & 0x1f) * (1.0F / 31.0F);
2302
               rgba[i][ACOMP] = 1.0F;
2303
            }
2304
         }
2305
         break;
2306
      case GL_UNSIGNED_SHORT_5_6_5_REV:
2307
         if (swapBytes) {
2308
            const GLushort *ussrc = (const GLushort *) src;
2309
            GLuint i;
2310
            for (i = 0; i < n; i ++) {
2311
               GLushort p = ussrc[i];
2312
               SWAP2BYTE(p);
2313
               rgba[i][RCOMP] = ((p      ) & 0x1f) * (1.0F / 31.0F);
2314
               rgba[i][GCOMP] = ((p >>  5) & 0x3f) * (1.0F / 63.0F);
2315
               rgba[i][BCOMP] = ((p >> 11)       ) * (1.0F / 31.0F);
2316
               rgba[i][ACOMP] = 1.0F;
2317
            }
2318
         }
2319
         else {
2320
            const GLushort *ussrc = (const GLushort *) src;
2321
            GLuint i;
2322
            for (i = 0; i < n; i ++) {
2323
               GLushort p = ussrc[i];
2324
               rgba[i][RCOMP] = ((p      ) & 0x1f) * (1.0F / 31.0F);
2325
               rgba[i][GCOMP] = ((p >>  5) & 0x3f) * (1.0F / 63.0F);
2326
               rgba[i][BCOMP] = ((p >> 11)       ) * (1.0F / 31.0F);
2327
               rgba[i][ACOMP] = 1.0F;
2328
            }
2329
         }
2330
         break;
2331
      case GL_UNSIGNED_SHORT_4_4_4_4:
2332
         if (swapBytes) {
2333
            const GLushort *ussrc = (const GLushort *) src;
2334
            GLuint i;
2335
            for (i = 0; i < n; i ++) {
2336
               GLushort p = ussrc[i];
2337
               SWAP2BYTE(p);
2338
               rgba[i][rComp] = ((p >> 12)      ) * (1.0F / 15.0F);
2339
               rgba[i][gComp] = ((p >>  8) & 0xf) * (1.0F / 15.0F);
2340
               rgba[i][bComp] = ((p >>  4) & 0xf) * (1.0F / 15.0F);
2341
               rgba[i][aComp] = ((p      ) & 0xf) * (1.0F / 15.0F);
2342
            }
2343
         }
2344
         else {
2345
            const GLushort *ussrc = (const GLushort *) src;
2346
            GLuint i;
2347
            for (i = 0; i < n; i ++) {
2348
               GLushort p = ussrc[i];
2349
               rgba[i][rComp] = ((p >> 12)      ) * (1.0F / 15.0F);
2350
               rgba[i][gComp] = ((p >>  8) & 0xf) * (1.0F / 15.0F);
2351
               rgba[i][bComp] = ((p >>  4) & 0xf) * (1.0F / 15.0F);
2352
               rgba[i][aComp] = ((p      ) & 0xf) * (1.0F / 15.0F);
2353
            }
2354
         }
2355
         break;
2356
      case GL_UNSIGNED_SHORT_4_4_4_4_REV:
2357
         if (swapBytes) {
2358
            const GLushort *ussrc = (const GLushort *) src;
2359
            GLuint i;
2360
            for (i = 0; i < n; i ++) {
2361
               GLushort p = ussrc[i];
2362
               SWAP2BYTE(p);
2363
               rgba[i][rComp] = ((p      ) & 0xf) * (1.0F / 15.0F);
2364
               rgba[i][gComp] = ((p >>  4) & 0xf) * (1.0F / 15.0F);
2365
               rgba[i][bComp] = ((p >>  8) & 0xf) * (1.0F / 15.0F);
2366
               rgba[i][aComp] = ((p >> 12)      ) * (1.0F / 15.0F);
2367
            }
2368
         }
2369
         else {
2370
            const GLushort *ussrc = (const GLushort *) src;
2371
            GLuint i;
2372
            for (i = 0; i < n; i ++) {
2373
               GLushort p = ussrc[i];
2374
               rgba[i][rComp] = ((p      ) & 0xf) * (1.0F / 15.0F);
2375
               rgba[i][gComp] = ((p >>  4) & 0xf) * (1.0F / 15.0F);
2376
               rgba[i][bComp] = ((p >>  8) & 0xf) * (1.0F / 15.0F);
2377
               rgba[i][aComp] = ((p >> 12)      ) * (1.0F / 15.0F);
2378
            }
2379
         }
2380
         break;
2381
      case GL_UNSIGNED_SHORT_5_5_5_1:
2382
         if (swapBytes) {
2383
            const GLushort *ussrc = (const GLushort *) src;
2384
            GLuint i;
2385
            for (i = 0; i < n; i ++) {
2386
               GLushort p = ussrc[i];
2387
               SWAP2BYTE(p);
2388
               rgba[i][rComp] = ((p >> 11)       ) * (1.0F / 31.0F);
2389
               rgba[i][gComp] = ((p >>  6) & 0x1f) * (1.0F / 31.0F);
2390
               rgba[i][bComp] = ((p >>  1) & 0x1f) * (1.0F / 31.0F);
2391
               rgba[i][aComp] = ((p      ) & 0x1)  * (1.0F /  1.0F);
2392
            }
2393
         }
2394
         else {
2395
            const GLushort *ussrc = (const GLushort *) src;
2396
            GLuint i;
2397
            for (i = 0; i < n; i ++) {
2398
               GLushort p = ussrc[i];
2399
               rgba[i][rComp] = ((p >> 11)       ) * (1.0F / 31.0F);
2400
               rgba[i][gComp] = ((p >>  6) & 0x1f) * (1.0F / 31.0F);
2401
               rgba[i][bComp] = ((p >>  1) & 0x1f) * (1.0F / 31.0F);
2402
               rgba[i][aComp] = ((p      ) & 0x1)  * (1.0F /  1.0F);
2403
            }
2404
         }
2405
         break;
2406
      case GL_UNSIGNED_SHORT_1_5_5_5_REV:
2407
         if (swapBytes) {
2408
            const GLushort *ussrc = (const GLushort *) src;
2409
            GLuint i;
2410
            for (i = 0; i < n; i ++) {
2411
               GLushort p = ussrc[i];
2412
               SWAP2BYTE(p);
2413
               rgba[i][rComp] = ((p      ) & 0x1f) * (1.0F / 31.0F);
2414
               rgba[i][gComp] = ((p >>  5) & 0x1f) * (1.0F / 31.0F);
2415
               rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2416
               rgba[i][aComp] = ((p >> 15)       ) * (1.0F /  1.0F);
2417
            }
2418
         }
2419
         else {
2420
            const GLushort *ussrc = (const GLushort *) src;
2421
            GLuint i;
2422
            for (i = 0; i < n; i ++) {
2423
               GLushort p = ussrc[i];
2424
               rgba[i][rComp] = ((p      ) & 0x1f) * (1.0F / 31.0F);
2425
               rgba[i][gComp] = ((p >>  5) & 0x1f) * (1.0F / 31.0F);
2426
               rgba[i][bComp] = ((p >> 10) & 0x1f) * (1.0F / 31.0F);
2427
               rgba[i][aComp] = ((p >> 15)       ) * (1.0F /  1.0F);
2428
            }
2429
         }
2430
         break;
2431
      case GL_UNSIGNED_INT_8_8_8_8:
2432
         if (swapBytes) {
2433
            const GLuint *uisrc = (const GLuint *) src;
2434
            GLuint i;
2435
            for (i = 0; i < n; i ++) {
2436
               GLuint p = uisrc[i];
2437
               rgba[i][rComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
2438
               rgba[i][gComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2439
               rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2440
               rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24)       );
2441
            }
2442
         }
2443
         else {
2444
            const GLuint *uisrc = (const GLuint *) src;
2445
            GLuint i;
2446
            for (i = 0; i < n; i ++) {
2447
               GLuint p = uisrc[i];
2448
               rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24)       );
2449
               rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2450
               rgba[i][bComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2451
               rgba[i][aComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
2452
            }
2453
         }
2454
         break;
2455
      case GL_UNSIGNED_INT_8_8_8_8_REV:
2456
         if (swapBytes) {
2457
            const GLuint *uisrc = (const GLuint *) src;
2458
            GLuint i;
2459
            for (i = 0; i < n; i ++) {
2460
               GLuint p = uisrc[i];
2461
               rgba[i][rComp] = UBYTE_TO_FLOAT((p >> 24)       );
2462
               rgba[i][gComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2463
               rgba[i][bComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2464
               rgba[i][aComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
2465
            }
2466
         }
2467
         else {
2468
            const GLuint *uisrc = (const GLuint *) src;
2469
            GLuint i;
2470
            for (i = 0; i < n; i ++) {
2471
               GLuint p = uisrc[i];
2472
               rgba[i][rComp] = UBYTE_TO_FLOAT((p      ) & 0xff);
2473
               rgba[i][gComp] = UBYTE_TO_FLOAT((p >>  8) & 0xff);
2474
               rgba[i][bComp] = UBYTE_TO_FLOAT((p >> 16) & 0xff);
2475
               rgba[i][aComp] = UBYTE_TO_FLOAT((p >> 24)       );
2476
            }
2477
         }
2478
         break;
2479
      case GL_UNSIGNED_INT_10_10_10_2:
2480
         if (swapBytes) {
2481
            const GLuint *uisrc = (const GLuint *) src;
2482
            GLuint i;
2483
            for (i = 0; i < n; i ++) {
2484
               GLuint p = uisrc[i];
2485
               SWAP4BYTE(p);
2486
               rgba[i][rComp] = ((p >> 22)        ) * (1.0F / 1023.0F);
2487
               rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2488
               rgba[i][bComp] = ((p >>  2) & 0x3ff) * (1.0F / 1023.0F);
2489
               rgba[i][aComp] = ((p      ) & 0x3  ) * (1.0F /    3.0F);
2490
            }
2491
         }
2492
         else {
2493
            const GLuint *uisrc = (const GLuint *) src;
2494
            GLuint i;
2495
            for (i = 0; i < n; i ++) {
2496
               GLuint p = uisrc[i];
2497
               rgba[i][rComp] = ((p >> 22)        ) * (1.0F / 1023.0F);
2498
               rgba[i][gComp] = ((p >> 12) & 0x3ff) * (1.0F / 1023.0F);
2499
               rgba[i][bComp] = ((p >>  2) & 0x3ff) * (1.0F / 1023.0F);
2500
               rgba[i][aComp] = ((p      ) & 0x3  ) * (1.0F /    3.0F);
2501
            }
2502
         }
2503
         break;
2504
      case GL_UNSIGNED_INT_2_10_10_10_REV:
2505
         if (swapBytes) {
2506
            const GLuint *uisrc = (const GLuint *) src;
2507
            GLuint i;
2508
            for (i = 0; i < n; i ++) {
2509
               GLuint p = uisrc[i];
2510
               SWAP4BYTE(p);
2511
               rgba[i][rComp] = ((p      ) & 0x3ff) * (1.0F / 1023.0F);
2512
               rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2513
               rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2514
               rgba[i][aComp] = ((p >> 30)        ) * (1.0F /    3.0F);
2515
            }
2516
         }
2517
         else {
2518
            const GLuint *uisrc = (const GLuint *) src;
2519
            GLuint i;
2520
            for (i = 0; i < n; i ++) {
2521
               GLuint p = uisrc[i];
2522
               rgba[i][rComp] = ((p      ) & 0x3ff) * (1.0F / 1023.0F);
2523
               rgba[i][gComp] = ((p >> 10) & 0x3ff) * (1.0F / 1023.0F);
2524
               rgba[i][bComp] = ((p >> 20) & 0x3ff) * (1.0F / 1023.0F);
2525
               rgba[i][aComp] = ((p >> 30)        ) * (1.0F /    3.0F);
2526
            }
2527
         }
2528
         break;
2529
      default:
2530
         _mesa_problem(NULL, "bad srcType in extract float data");
2531
         break;
2532
   }
2533
}
2534
 
2535
 
2536
 
2537
/*
2538
 * Unpack a row of color image data from a client buffer according to
2539
 * the pixel unpacking parameters.
2540
 * Return GLubyte values in the specified dest image format.
2541
 * This is (or will be) used by glDrawPixels and glTexImage?D().
2542
 * Input:  ctx - the context
2543
 *         n - number of pixels in the span
2544
 *         dstFormat - format of destination color array
2545
 *         dest - the destination color array
2546
 *         srcFormat - source image format
2547
 *         srcType - source image  datatype
2548
 *         source - source image pointer
2549
 *         srcPacking - pixel unpacking parameters
2550
 *         transferOps - bitmask of IMAGE_*_BIT values of operations to apply
2551
 *
2552
 * XXX perhaps expand this to process whole images someday.
2553
 */
2554
void
2555
_mesa_unpack_chan_color_span( GLcontext *ctx,
2556
                              GLuint n, GLenum dstFormat, GLchan dest[],
2557
                              GLenum srcFormat, GLenum srcType,
2558
                              const GLvoid *source,
2559
                              const struct gl_pixelstore_attrib *srcPacking,
2560
                              GLuint transferOps )
2561
{
2562
   ASSERT(dstFormat == GL_ALPHA ||
2563
          dstFormat == GL_LUMINANCE ||
2564
          dstFormat == GL_LUMINANCE_ALPHA ||
2565
          dstFormat == GL_INTENSITY ||
2566
          dstFormat == GL_RGB ||
2567
          dstFormat == GL_RGBA ||
2568
          dstFormat == GL_COLOR_INDEX);
2569
 
2570
   ASSERT(srcFormat == GL_RED ||
2571
          srcFormat == GL_GREEN ||
2572
          srcFormat == GL_BLUE ||
2573
          srcFormat == GL_ALPHA ||
2574
          srcFormat == GL_LUMINANCE ||
2575
          srcFormat == GL_LUMINANCE_ALPHA ||
2576
          srcFormat == GL_INTENSITY ||
2577
          srcFormat == GL_RGB ||
2578
          srcFormat == GL_BGR ||
2579
          srcFormat == GL_RGBA ||
2580
          srcFormat == GL_BGRA ||
2581
          srcFormat == GL_ABGR_EXT ||
2582
          srcFormat == GL_COLOR_INDEX);
2583
 
2584
   ASSERT(srcType == GL_BITMAP ||
2585
          srcType == GL_UNSIGNED_BYTE ||
2586
          srcType == GL_BYTE ||
2587
          srcType == GL_UNSIGNED_SHORT ||
2588
          srcType == GL_SHORT ||
2589
          srcType == GL_UNSIGNED_INT ||
2590
          srcType == GL_INT ||
2591
          srcType == GL_FLOAT ||
2592
          srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2593
          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2594
          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2595
          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2596
          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2597
          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2598
          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2599
          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2600
          srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2601
          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2602
          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2603
          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2604
 
2605
   /* Try simple cases first */
2606
   if (transferOps == 0 ){
2607
      if (srcType == CHAN_TYPE) {
2608
         if (dstFormat == GL_RGBA) {
2609
            if (srcFormat == GL_RGBA) {
2610
               MEMCPY( dest, source, n * 4 * sizeof(GLchan) );
2611
               return;
2612
            }
2613
            else if (srcFormat == GL_RGB) {
2614
               GLuint i;
2615
               const GLchan *src = (const GLchan *) source;
2616
               GLchan *dst = dest;
2617
               for (i = 0; i < n; i++) {
2618
                  dst[0] = src[0];
2619
                  dst[1] = src[1];
2620
                  dst[2] = src[2];
2621
                  dst[3] = CHAN_MAX;
2622
                  src += 3;
2623
                  dst += 4;
2624
               }
2625
               return;
2626
            }
2627
         }
2628
         else if (dstFormat == GL_RGB) {
2629
            if (srcFormat == GL_RGB) {
2630
               MEMCPY( dest, source, n * 3 * sizeof(GLchan) );
2631
               return;
2632
            }
2633
            else if (srcFormat == GL_RGBA) {
2634
               GLuint i;
2635
               const GLchan *src = (const GLchan *) source;
2636
               GLchan *dst = dest;
2637
               for (i = 0; i < n; i++) {
2638
                  dst[0] = src[0];
2639
                  dst[1] = src[1];
2640
                  dst[2] = src[2];
2641
                  src += 4;
2642
                  dst += 3;
2643
               }
2644
               return;
2645
            }
2646
         }
2647
         else if (dstFormat == srcFormat) {
2648
            GLint comps = _mesa_components_in_format(srcFormat);
2649
            assert(comps > 0);
2650
            MEMCPY( dest, source, n * comps * sizeof(GLchan) );
2651
            return;
2652
         }
2653
      }
2654
      /*
2655
       * Common situation, loading 8bit RGBA/RGB source images
2656
       * into 16/32 bit destination. (OSMesa16/32)
2657
       */
2658
      else if (srcType == GL_UNSIGNED_BYTE) {
2659
         if (dstFormat == GL_RGBA) {
2660
            if (srcFormat == GL_RGB) {
2661
               GLuint i;
2662
               const GLubyte *src = (const GLubyte *) source;
2663
               GLchan *dst = dest;
2664
               for (i = 0; i < n; i++) {
2665
                  dst[0] = UBYTE_TO_CHAN(src[0]);
2666
                  dst[1] = UBYTE_TO_CHAN(src[1]);
2667
                  dst[2] = UBYTE_TO_CHAN(src[2]);
2668
                  dst[3] = CHAN_MAX;
2669
                  src += 3;
2670
                  dst += 4;
2671
               }
2672
               return;
2673
            }
2674
            else if (srcFormat == GL_RGBA) {
2675
               GLuint i;
2676
               const GLubyte *src = (const GLubyte *) source;
2677
               GLchan *dst = dest;
2678
               for (i = 0; i < n; i++) {
2679
                  dst[0] = UBYTE_TO_CHAN(src[0]);
2680
                  dst[1] = UBYTE_TO_CHAN(src[1]);
2681
                  dst[2] = UBYTE_TO_CHAN(src[2]);
2682
                  dst[3] = UBYTE_TO_CHAN(src[3]);
2683
                  src += 4;
2684
                  dst += 4;
2685
               }
2686
               return;
2687
             }
2688
         }
2689
         else if (dstFormat == GL_RGB) {
2690
            if (srcFormat == GL_RGB) {
2691
               GLuint i;
2692
               const GLubyte *src = (const GLubyte *) source;
2693
               GLchan *dst = dest;
2694
               for (i = 0; i < n; i++) {
2695
                  dst[0] = UBYTE_TO_CHAN(src[0]);
2696
                  dst[1] = UBYTE_TO_CHAN(src[1]);
2697
                  dst[2] = UBYTE_TO_CHAN(src[2]);
2698
                  src += 3;
2699
                  dst += 3;
2700
               }
2701
               return;
2702
            }
2703
            else if (srcFormat == GL_RGBA) {
2704
               GLuint i;
2705
               const GLubyte *src = (const GLubyte *) source;
2706
               GLchan *dst = dest;
2707
               for (i = 0; i < n; i++) {
2708
                  dst[0] = UBYTE_TO_CHAN(src[0]);
2709
                  dst[1] = UBYTE_TO_CHAN(src[1]);
2710
                  dst[2] = UBYTE_TO_CHAN(src[2]);
2711
                  src += 4;
2712
                  dst += 3;
2713
               }
2714
               return;
2715
            }
2716
         }
2717
      }
2718
   }
2719
 
2720
 
2721
   /* general solution begins here */
2722
   {
2723
      GLint dstComponents;
2724
      GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
2725
      GLint dstLuminanceIndex, dstIntensityIndex;
2726
      DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
2727
      CHECKARRAY(rgba, return);  /* mac 32k limitation */
2728
 
2729
      dstComponents = _mesa_components_in_format( dstFormat );
2730
      /* source & dest image formats should have been error checked by now */
2731
      assert(dstComponents > 0);
2732
 
2733
      /*
2734
       * Extract image data and convert to RGBA floats
2735
       */
2736
      assert(n <= MAX_WIDTH);
2737
      if (srcFormat == GL_COLOR_INDEX) {
2738
         GLuint indexes[MAX_WIDTH];
2739
         extract_uint_indexes(n, indexes, srcFormat, srcType, source,
2740
                              srcPacking);
2741
 
2742
         if (dstFormat == GL_COLOR_INDEX
2743
             && (transferOps & IMAGE_MAP_COLOR_BIT)) {
2744
            _mesa_map_ci(ctx, n, indexes);
2745
         }
2746
         if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
2747
            _mesa_shift_and_offset_ci(ctx, n, indexes);
2748
         }
2749
 
2750
         if (dstFormat == GL_COLOR_INDEX) {
2751
            /* convert to GLchan and return */
2752
            GLuint i;
2753
            for (i = 0; i < n; i++) {
2754
               dest[i] = (GLchan) (indexes[i] & 0xff);
2755
            }
2756
            UNDEFARRAY(rgba);  /* mac 32k limitation */
2757
            return;
2758
         }
2759
         else {
2760
            /* Convert indexes to RGBA */
2761
            _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
2762
         }
2763
      }
2764
      else {
2765
         extract_float_rgba(n, rgba, srcFormat, srcType, source,
2766
                            srcPacking->SwapBytes);
2767
 
2768
         /* scale and bias colors */
2769
         if (transferOps & IMAGE_SCALE_BIAS_BIT) {
2770
            _mesa_scale_and_bias_rgba(ctx, n, rgba,
2771
                                   ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
2772
                                   ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
2773
                                   ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
2774
                                   ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
2775
         }
2776
         /* color map lookup */
2777
         if (transferOps & IMAGE_MAP_COLOR_BIT) {
2778
            _mesa_map_rgba(ctx, n, rgba);
2779
         }
2780
      }
2781
 
2782
      if (transferOps) {
2783
         /* GL_COLOR_TABLE lookup */
2784
         if (transferOps & IMAGE_COLOR_TABLE_BIT) {
2785
            _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
2786
         }
2787
         /* convolution */
2788
         if (transferOps & IMAGE_CONVOLUTION_BIT) {
2789
            /* this has to be done in the calling code */
2790
         }
2791
         /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
2792
         if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
2793
            _mesa_scale_and_bias_rgba(ctx, n, rgba,
2794
                                      ctx->Pixel.PostConvolutionScale[RCOMP],
2795
                                      ctx->Pixel.PostConvolutionScale[GCOMP],
2796
                                      ctx->Pixel.PostConvolutionScale[BCOMP],
2797
                                      ctx->Pixel.PostConvolutionScale[ACOMP],
2798
                                      ctx->Pixel.PostConvolutionBias[RCOMP],
2799
                                      ctx->Pixel.PostConvolutionBias[GCOMP],
2800
                                      ctx->Pixel.PostConvolutionBias[BCOMP],
2801
                                      ctx->Pixel.PostConvolutionBias[ACOMP]);
2802
         }
2803
         /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
2804
         if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
2805
            _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
2806
         }
2807
         /* color matrix transform */
2808
         if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
2809
            _mesa_transform_rgba(ctx, n, rgba);
2810
         }
2811
         /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
2812
         if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
2813
            _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
2814
         }
2815
         /* update histogram count */
2816
         if (transferOps & IMAGE_HISTOGRAM_BIT) {
2817
            _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
2818
         }
2819
         /* min/max here */
2820
         if (transferOps & IMAGE_MIN_MAX_BIT) {
2821
            _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
2822
         }
2823
      }
2824
 
2825
      /* clamp to [0,1] */
2826
#if CHAN_TYPE != GL_FLOAT
2827
      {
2828
         GLuint i;
2829
         for (i = 0; i < n; i++) {
2830
            rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
2831
            rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
2832
            rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
2833
            rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
2834
         }
2835
      }
2836
#endif
2837
 
2838
      /* Now determine which color channels we need to produce.
2839
       * And determine the dest index (offset) within each color tuple.
2840
       */
2841
      switch (dstFormat) {
2842
         case GL_ALPHA:
2843
            dstAlphaIndex = 0;
2844
            dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2845
            dstLuminanceIndex = dstIntensityIndex = -1;
2846
            break;
2847
         case GL_LUMINANCE:
2848
            dstLuminanceIndex = 0;
2849
            dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2850
            dstIntensityIndex = -1;
2851
            break;
2852
         case GL_LUMINANCE_ALPHA:
2853
            dstLuminanceIndex = 0;
2854
            dstAlphaIndex = 1;
2855
            dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
2856
            dstIntensityIndex = -1;
2857
            break;
2858
         case GL_INTENSITY:
2859
            dstIntensityIndex = 0;
2860
            dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
2861
            dstLuminanceIndex = -1;
2862
            break;
2863
         case GL_RGB:
2864
            dstRedIndex = 0;
2865
            dstGreenIndex = 1;
2866
            dstBlueIndex = 2;
2867
            dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
2868
            break;
2869
         case GL_RGBA:
2870
            dstRedIndex = 0;
2871
            dstGreenIndex = 1;
2872
            dstBlueIndex = 2;
2873
            dstAlphaIndex = 3;
2874
            dstLuminanceIndex = dstIntensityIndex = -1;
2875
            break;
2876
         default:
2877
            _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_chan_span()");
2878
            UNDEFARRAY(rgba);  /* mac 32k limitation */
2879
            return;
2880
      }
2881
 
2882
 
2883
      /* Now return the GLchan data in the requested dstFormat */
2884
 
2885
      if (dstRedIndex >= 0) {
2886
         GLchan *dst = dest;
2887
         GLuint i;
2888
         for (i = 0; i < n; i++) {
2889
            CLAMPED_FLOAT_TO_CHAN(dst[dstRedIndex], rgba[i][RCOMP]);
2890
            dst += dstComponents;
2891
         }
2892
      }
2893
 
2894
      if (dstGreenIndex >= 0) {
2895
         GLchan *dst = dest;
2896
         GLuint i;
2897
         for (i = 0; i < n; i++) {
2898
            CLAMPED_FLOAT_TO_CHAN(dst[dstGreenIndex], rgba[i][GCOMP]);
2899
            dst += dstComponents;
2900
         }
2901
      }
2902
 
2903
      if (dstBlueIndex >= 0) {
2904
         GLchan *dst = dest;
2905
         GLuint i;
2906
         for (i = 0; i < n; i++) {
2907
            CLAMPED_FLOAT_TO_CHAN(dst[dstBlueIndex], rgba[i][BCOMP]);
2908
            dst += dstComponents;
2909
         }
2910
      }
2911
 
2912
      if (dstAlphaIndex >= 0) {
2913
         GLchan *dst = dest;
2914
         GLuint i;
2915
         for (i = 0; i < n; i++) {
2916
            CLAMPED_FLOAT_TO_CHAN(dst[dstAlphaIndex], rgba[i][ACOMP]);
2917
            dst += dstComponents;
2918
         }
2919
      }
2920
 
2921
      if (dstIntensityIndex >= 0) {
2922
         GLchan *dst = dest;
2923
         GLuint i;
2924
         assert(dstIntensityIndex == 0);
2925
         assert(dstComponents == 1);
2926
         for (i = 0; i < n; i++) {
2927
            /* Intensity comes from red channel */
2928
            CLAMPED_FLOAT_TO_CHAN(dst[i], rgba[i][RCOMP]);
2929
         }
2930
      }
2931
 
2932
      if (dstLuminanceIndex >= 0) {
2933
         GLchan *dst = dest;
2934
         GLuint i;
2935
         assert(dstLuminanceIndex == 0);
2936
         for (i = 0; i < n; i++) {
2937
            /* Luminance comes from red channel */
2938
            CLAMPED_FLOAT_TO_CHAN(dst[0], rgba[i][RCOMP]);
2939
            dst += dstComponents;
2940
         }
2941
      }
2942
      UNDEFARRAY(rgba);  /* mac 32k limitation */
2943
   }
2944
}
2945
 
2946
 
2947
void
2948
_mesa_unpack_float_color_span( GLcontext *ctx,
2949
                               GLuint n, GLenum dstFormat, GLfloat dest[],
2950
                               GLenum srcFormat, GLenum srcType,
2951
                               const GLvoid *source,
2952
                               const struct gl_pixelstore_attrib *srcPacking,
2953
                               GLuint transferOps, GLboolean clamp )
2954
{
2955
   ASSERT(dstFormat == GL_ALPHA ||
2956
          dstFormat == GL_LUMINANCE ||
2957
          dstFormat == GL_LUMINANCE_ALPHA ||
2958
          dstFormat == GL_INTENSITY ||
2959
          dstFormat == GL_RGB ||
2960
          dstFormat == GL_RGBA ||
2961
          dstFormat == GL_COLOR_INDEX);
2962
 
2963
   ASSERT(srcFormat == GL_RED ||
2964
          srcFormat == GL_GREEN ||
2965
          srcFormat == GL_BLUE ||
2966
          srcFormat == GL_ALPHA ||
2967
          srcFormat == GL_LUMINANCE ||
2968
          srcFormat == GL_LUMINANCE_ALPHA ||
2969
          srcFormat == GL_INTENSITY ||
2970
          srcFormat == GL_RGB ||
2971
          srcFormat == GL_BGR ||
2972
          srcFormat == GL_RGBA ||
2973
          srcFormat == GL_BGRA ||
2974
          srcFormat == GL_ABGR_EXT ||
2975
          srcFormat == GL_COLOR_INDEX);
2976
 
2977
   ASSERT(srcType == GL_BITMAP ||
2978
          srcType == GL_UNSIGNED_BYTE ||
2979
          srcType == GL_BYTE ||
2980
          srcType == GL_UNSIGNED_SHORT ||
2981
          srcType == GL_SHORT ||
2982
          srcType == GL_UNSIGNED_INT ||
2983
          srcType == GL_INT ||
2984
          srcType == GL_FLOAT ||
2985
          srcType == GL_UNSIGNED_BYTE_3_3_2 ||
2986
          srcType == GL_UNSIGNED_BYTE_2_3_3_REV ||
2987
          srcType == GL_UNSIGNED_SHORT_5_6_5 ||
2988
          srcType == GL_UNSIGNED_SHORT_5_6_5_REV ||
2989
          srcType == GL_UNSIGNED_SHORT_4_4_4_4 ||
2990
          srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ||
2991
          srcType == GL_UNSIGNED_SHORT_5_5_5_1 ||
2992
          srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ||
2993
          srcType == GL_UNSIGNED_INT_8_8_8_8 ||
2994
          srcType == GL_UNSIGNED_INT_8_8_8_8_REV ||
2995
          srcType == GL_UNSIGNED_INT_10_10_10_2 ||
2996
          srcType == GL_UNSIGNED_INT_2_10_10_10_REV);
2997
 
2998
   /* general solution, no special cases, yet */
2999
   {
3000
      GLint dstComponents;
3001
      GLint dstRedIndex, dstGreenIndex, dstBlueIndex, dstAlphaIndex;
3002
      GLint dstLuminanceIndex, dstIntensityIndex;
3003
      DEFMARRAY(GLfloat, rgba, MAX_WIDTH, 4);  /* mac 32k limitation */
3004
      CHECKARRAY(rgba, return);  /* mac 32k limitation */
3005
 
3006
      dstComponents = _mesa_components_in_format( dstFormat );
3007
      /* source & dest image formats should have been error checked by now */
3008
      assert(dstComponents > 0);
3009
 
3010
      /*
3011
       * Extract image data and convert to RGBA floats
3012
       */
3013
      assert(n <= MAX_WIDTH);
3014
      if (srcFormat == GL_COLOR_INDEX) {
3015
         GLuint indexes[MAX_WIDTH];
3016
         extract_uint_indexes(n, indexes, srcFormat, srcType, source,
3017
                              srcPacking);
3018
 
3019
         if (dstFormat == GL_COLOR_INDEX
3020
             && (transferOps & IMAGE_MAP_COLOR_BIT)) {
3021
            _mesa_map_ci(ctx, n, indexes);
3022
         }
3023
         if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3024
            _mesa_shift_and_offset_ci(ctx, n, indexes);
3025
         }
3026
 
3027
         if (dstFormat == GL_COLOR_INDEX) {
3028
            /* convert to GLchan and return */
3029
            GLuint i;
3030
            for (i = 0; i < n; i++) {
3031
               dest[i] = (GLchan) (indexes[i] & 0xff);
3032
            }
3033
            UNDEFARRAY(rgba);  /* mac 32k limitation */
3034
            return;
3035
         }
3036
         else {
3037
            /* Convert indexes to RGBA */
3038
            _mesa_map_ci_to_rgba(ctx, n, indexes, rgba);
3039
         }
3040
      }
3041
      else {
3042
         extract_float_rgba(n, rgba, srcFormat, srcType, source,
3043
                            srcPacking->SwapBytes);
3044
 
3045
         /* scale and bias colors */
3046
         if (transferOps & IMAGE_SCALE_BIAS_BIT) {
3047
            _mesa_scale_and_bias_rgba(ctx, n, rgba,
3048
                                   ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
3049
                                   ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
3050
                                   ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
3051
                                   ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
3052
         }
3053
         /* color map lookup */
3054
         if (transferOps & IMAGE_MAP_COLOR_BIT) {
3055
            _mesa_map_rgba(ctx, n, rgba);
3056
         }
3057
      }
3058
 
3059
      if (transferOps) {
3060
         /* GL_COLOR_TABLE lookup */
3061
         if (transferOps & IMAGE_COLOR_TABLE_BIT) {
3062
            _mesa_lookup_rgba(&ctx->ColorTable, n, rgba);
3063
         }
3064
         /* convolution */
3065
         if (transferOps & IMAGE_CONVOLUTION_BIT) {
3066
            /* XXX to do */
3067
         }
3068
         /* GL_POST_CONVOLUTION_RED/GREEN/BLUE/ALPHA_SCALE/BIAS */
3069
         if (transferOps & IMAGE_POST_CONVOLUTION_SCALE_BIAS) {
3070
            _mesa_scale_and_bias_rgba(ctx, n, rgba,
3071
                                      ctx->Pixel.PostConvolutionScale[RCOMP],
3072
                                      ctx->Pixel.PostConvolutionScale[GCOMP],
3073
                                      ctx->Pixel.PostConvolutionScale[BCOMP],
3074
                                      ctx->Pixel.PostConvolutionScale[ACOMP],
3075
                                      ctx->Pixel.PostConvolutionBias[RCOMP],
3076
                                      ctx->Pixel.PostConvolutionBias[GCOMP],
3077
                                      ctx->Pixel.PostConvolutionBias[BCOMP],
3078
                                      ctx->Pixel.PostConvolutionBias[ACOMP]);
3079
         }
3080
         /* GL_POST_CONVOLUTION_COLOR_TABLE lookup */
3081
         if (transferOps & IMAGE_POST_CONVOLUTION_COLOR_TABLE_BIT) {
3082
            _mesa_lookup_rgba(&ctx->PostConvolutionColorTable, n, rgba);
3083
         }
3084
         /* color matrix transform */
3085
         if (transferOps & IMAGE_COLOR_MATRIX_BIT) {
3086
            _mesa_transform_rgba(ctx, n, rgba);
3087
         }
3088
         /* GL_POST_COLOR_MATRIX_COLOR_TABLE lookup */
3089
         if (transferOps & IMAGE_POST_COLOR_MATRIX_COLOR_TABLE_BIT) {
3090
            _mesa_lookup_rgba(&ctx->PostColorMatrixColorTable, n, rgba);
3091
         }
3092
         /* update histogram count */
3093
         if (transferOps & IMAGE_HISTOGRAM_BIT) {
3094
            _mesa_update_histogram(ctx, n, (CONST GLfloat (*)[4]) rgba);
3095
         }
3096
         /* min/max here */
3097
         if (transferOps & IMAGE_MIN_MAX_BIT) {
3098
            _mesa_update_minmax(ctx, n, (CONST GLfloat (*)[4]) rgba);
3099
         }
3100
      }
3101
 
3102
      /* clamp to [0,1] */
3103
#if CHAN_TYPE != GL_FLOAT
3104
      if (clamp) {
3105
         GLuint i;
3106
         for (i = 0; i < n; i++) {
3107
            rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
3108
            rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
3109
            rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
3110
            rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
3111
         }
3112
      }
3113
#endif
3114
 
3115
      /* Now determine which color channels we need to produce.
3116
       * And determine the dest index (offset) within each color tuple.
3117
       */
3118
      switch (dstFormat) {
3119
         case GL_ALPHA:
3120
            dstAlphaIndex = 0;
3121
            dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3122
            dstLuminanceIndex = dstIntensityIndex = -1;
3123
            break;
3124
         case GL_LUMINANCE:
3125
            dstLuminanceIndex = 0;
3126
            dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3127
            dstIntensityIndex = -1;
3128
            break;
3129
         case GL_LUMINANCE_ALPHA:
3130
            dstLuminanceIndex = 0;
3131
            dstAlphaIndex = 1;
3132
            dstRedIndex = dstGreenIndex = dstBlueIndex = -1;
3133
            dstIntensityIndex = -1;
3134
            break;
3135
         case GL_INTENSITY:
3136
            dstIntensityIndex = 0;
3137
            dstRedIndex = dstGreenIndex = dstBlueIndex = dstAlphaIndex = -1;
3138
            dstLuminanceIndex = -1;
3139
            break;
3140
         case GL_RGB:
3141
            dstRedIndex = 0;
3142
            dstGreenIndex = 1;
3143
            dstBlueIndex = 2;
3144
            dstAlphaIndex = dstLuminanceIndex = dstIntensityIndex = -1;
3145
            break;
3146
         case GL_RGBA:
3147
            dstRedIndex = 0;
3148
            dstGreenIndex = 1;
3149
            dstBlueIndex = 2;
3150
            dstAlphaIndex = 3;
3151
            dstLuminanceIndex = dstIntensityIndex = -1;
3152
            break;
3153
         default:
3154
            _mesa_problem(ctx, "bad dstFormat in _mesa_unpack_float_color_span()");
3155
            UNDEFARRAY(rgba);  /* mac 32k limitation */
3156
            return;
3157
      }
3158
 
3159
      /* Now pack results in the requested dstFormat */
3160
      if (dstRedIndex >= 0) {
3161
         GLfloat *dst = dest;
3162
         GLuint i;
3163
         for (i = 0; i < n; i++) {
3164
            dst[dstRedIndex] = rgba[i][RCOMP];
3165
            dst += dstComponents;
3166
         }
3167
      }
3168
 
3169
      if (dstGreenIndex >= 0) {
3170
         GLfloat *dst = dest;
3171
         GLuint i;
3172
         for (i = 0; i < n; i++) {
3173
            dst[dstGreenIndex] = rgba[i][GCOMP];
3174
            dst += dstComponents;
3175
         }
3176
      }
3177
 
3178
      if (dstBlueIndex >= 0) {
3179
         GLfloat *dst = dest;
3180
         GLuint i;
3181
         for (i = 0; i < n; i++) {
3182
            dst[dstBlueIndex] = rgba[i][BCOMP];
3183
            dst += dstComponents;
3184
         }
3185
      }
3186
 
3187
      if (dstAlphaIndex >= 0) {
3188
         GLfloat *dst = dest;
3189
         GLuint i;
3190
         for (i = 0; i < n; i++) {
3191
            dst[dstAlphaIndex] = rgba[i][ACOMP];
3192
            dst += dstComponents;
3193
         }
3194
      }
3195
 
3196
      if (dstIntensityIndex >= 0) {
3197
         GLfloat *dst = dest;
3198
         GLuint i;
3199
         assert(dstIntensityIndex == 0);
3200
         assert(dstComponents == 1);
3201
         for (i = 0; i < n; i++) {
3202
            /* Intensity comes from red channel */
3203
            dst[i] = rgba[i][RCOMP];
3204
         }
3205
      }
3206
 
3207
      if (dstLuminanceIndex >= 0) {
3208
         GLfloat *dst = dest;
3209
         GLuint i;
3210
         assert(dstLuminanceIndex == 0);
3211
         for (i = 0; i < n; i++) {
3212
            /* Luminance comes from red channel */
3213
            dst[0] = rgba[i][RCOMP];
3214
            dst += dstComponents;
3215
         }
3216
      }
3217
      UNDEFARRAY(rgba);  /* mac 32k limitation */
3218
   }
3219
}
3220
 
3221
 
3222
 
3223
 
3224
/*
3225
 * Unpack a row of color index data from a client buffer according to
3226
 * the pixel unpacking parameters.
3227
 * This is (or will be) used by glDrawPixels, glTexImage[123]D, etc.
3228
 *
3229
 * Args:  ctx - the context
3230
 *        n - number of pixels
3231
 *        dstType - destination datatype
3232
 *        dest - destination array
3233
 *        srcType - source pixel type
3234
 *        source - source data pointer
3235
 *        srcPacking - pixel unpacking parameters
3236
 *        transferOps - the pixel transfer operations to apply
3237
 */
3238
void
3239
_mesa_unpack_index_span( const GLcontext *ctx, GLuint n,
3240
                         GLenum dstType, GLvoid *dest,
3241
                         GLenum srcType, const GLvoid *source,
3242
                         const struct gl_pixelstore_attrib *srcPacking,
3243
                         GLuint transferOps )
3244
{
3245
   ASSERT(srcType == GL_BITMAP ||
3246
          srcType == GL_UNSIGNED_BYTE ||
3247
          srcType == GL_BYTE ||
3248
          srcType == GL_UNSIGNED_SHORT ||
3249
          srcType == GL_SHORT ||
3250
          srcType == GL_UNSIGNED_INT ||
3251
          srcType == GL_INT ||
3252
          srcType == GL_FLOAT);
3253
 
3254
   ASSERT(dstType == GL_UNSIGNED_BYTE ||
3255
          dstType == GL_UNSIGNED_SHORT ||
3256
          dstType == GL_UNSIGNED_INT);
3257
 
3258
 
3259
   transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3260
 
3261
   /*
3262
    * Try simple cases first
3263
    */
3264
   if (transferOps == 0 && srcType == GL_UNSIGNED_BYTE
3265
       && dstType == GL_UNSIGNED_BYTE) {
3266
      MEMCPY(dest, source, n * sizeof(GLubyte));
3267
   }
3268
   else if (transferOps == 0 && srcType == GL_UNSIGNED_INT
3269
            && dstType == GL_UNSIGNED_INT && !srcPacking->SwapBytes) {
3270
      MEMCPY(dest, source, n * sizeof(GLuint));
3271
   }
3272
   else {
3273
      /*
3274
       * general solution
3275
       */
3276
      GLuint indexes[MAX_WIDTH];
3277
      assert(n <= MAX_WIDTH);
3278
 
3279
      extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3280
                           srcPacking);
3281
 
3282
      if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3283
         /* shift and offset indexes */
3284
         _mesa_shift_and_offset_ci(ctx, n, indexes);
3285
      }
3286
      if (transferOps & IMAGE_MAP_COLOR_BIT) {
3287
         /* Apply lookup table */
3288
         _mesa_map_ci(ctx, n, indexes);
3289
      }
3290
 
3291
      /* convert to dest type */
3292
      switch (dstType) {
3293
         case GL_UNSIGNED_BYTE:
3294
            {
3295
               GLubyte *dst = (GLubyte *) dest;
3296
               GLuint i;
3297
               for (i = 0; i < n; i++) {
3298
                  dst[i] = (GLubyte) (indexes[i] & 0xff);
3299
               }
3300
            }
3301
            break;
3302
         case GL_UNSIGNED_SHORT:
3303
            {
3304
               GLuint *dst = (GLuint *) dest;
3305
               GLuint i;
3306
               for (i = 0; i < n; i++) {
3307
                  dst[i] = (GLushort) (indexes[i] & 0xffff);
3308
               }
3309
            }
3310
            break;
3311
         case GL_UNSIGNED_INT:
3312
            MEMCPY(dest, indexes, n * sizeof(GLuint));
3313
            break;
3314
         default:
3315
            _mesa_problem(ctx, "bad dstType in _mesa_unpack_index_span");
3316
      }
3317
   }
3318
}
3319
 
3320
 
3321
void
3322
_mesa_pack_index_span( const GLcontext *ctx, GLuint n,
3323
                       GLenum dstType, GLvoid *dest, const GLuint *source,
3324
                       const struct gl_pixelstore_attrib *dstPacking,
3325
                       GLuint transferOps )
3326
{
3327
   GLuint indexes[MAX_WIDTH];
3328
 
3329
   ASSERT(n <= MAX_WIDTH);
3330
 
3331
   transferOps &= (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT);
3332
 
3333
   if (transferOps & (IMAGE_MAP_COLOR_BIT | IMAGE_SHIFT_OFFSET_BIT)) {
3334
      /* make a copy of input */
3335
      MEMCPY(indexes, source, n * sizeof(GLuint));
3336
      if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3337
         _mesa_shift_and_offset_ci( ctx, n, indexes);
3338
      }
3339
      if (transferOps & IMAGE_MAP_COLOR_BIT) {
3340
         _mesa_map_ci(ctx, n, indexes);
3341
      }
3342
      source = indexes;
3343
   }
3344
 
3345
   switch (dstType) {
3346
   case GL_UNSIGNED_BYTE:
3347
      {
3348
         GLubyte *dst = (GLubyte *) dest;
3349
         GLuint i;
3350
         for (i = 0; i < n; i++) {
3351
            *dst++ = (GLubyte) source[i];
3352
         }
3353
      }
3354
      break;
3355
   case GL_BYTE:
3356
      {
3357
         GLbyte *dst = (GLbyte *) dest;
3358
         GLuint i;
3359
         for (i = 0; i < n; i++) {
3360
            dst[i] = (GLbyte) source[i];
3361
         }
3362
      }
3363
      break;
3364
   case GL_UNSIGNED_SHORT:
3365
      {
3366
         GLushort *dst = (GLushort *) dest;
3367
         GLuint i;
3368
         for (i = 0; i < n; i++) {
3369
            dst[i] = (GLushort) source[i];
3370
         }
3371
         if (dstPacking->SwapBytes) {
3372
            _mesa_swap2( (GLushort *) dst, n );
3373
         }
3374
      }
3375
      break;
3376
   case GL_SHORT:
3377
      {
3378
         GLshort *dst = (GLshort *) dest;
3379
         GLuint i;
3380
         for (i = 0; i < n; i++) {
3381
            dst[i] = (GLshort) source[i];
3382
         }
3383
         if (dstPacking->SwapBytes) {
3384
            _mesa_swap2( (GLushort *) dst, n );
3385
         }
3386
      }
3387
      break;
3388
   case GL_UNSIGNED_INT:
3389
      {
3390
         GLuint *dst = (GLuint *) dest;
3391
         GLuint i;
3392
         for (i = 0; i < n; i++) {
3393
            dst[i] = (GLuint) source[i];
3394
         }
3395
         if (dstPacking->SwapBytes) {
3396
            _mesa_swap4( (GLuint *) dst, n );
3397
         }
3398
      }
3399
      break;
3400
   case GL_INT:
3401
      {
3402
         GLint *dst = (GLint *) dest;
3403
         GLuint i;
3404
         for (i = 0; i < n; i++) {
3405
            dst[i] = (GLint) source[i];
3406
         }
3407
         if (dstPacking->SwapBytes) {
3408
            _mesa_swap4( (GLuint *) dst, n );
3409
         }
3410
      }
3411
      break;
3412
   case GL_FLOAT:
3413
      {
3414
         GLfloat *dst = (GLfloat *) dest;
3415
         GLuint i;
3416
         for (i = 0; i < n; i++) {
3417
            dst[i] = (GLfloat) source[i];
3418
         }
3419
         if (dstPacking->SwapBytes) {
3420
            _mesa_swap4( (GLuint *) dst, n );
3421
         }
3422
      }
3423
      break;
3424
   default:
3425
      _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3426
   }
3427
}
3428
 
3429
 
3430
 
3431
/*
3432
 * Unpack a row of stencil data from a client buffer according to
3433
 * the pixel unpacking parameters.
3434
 * This is (or will be) used by glDrawPixels
3435
 *
3436
 * Args:  ctx - the context
3437
 *        n - number of pixels
3438
 *        dstType - destination datatype
3439
 *        dest - destination array
3440
 *        srcType - source pixel type
3441
 *        source - source data pointer
3442
 *        srcPacking - pixel unpacking parameters
3443
 *        transferOps - apply offset/bias/lookup ops?
3444
 */
3445
void
3446
_mesa_unpack_stencil_span( const GLcontext *ctx, GLuint n,
3447
                           GLenum dstType, GLvoid *dest,
3448
                           GLenum srcType, const GLvoid *source,
3449
                           const struct gl_pixelstore_attrib *srcPacking,
3450
                           GLuint transferOps )
3451
{
3452
   ASSERT(srcType == GL_BITMAP ||
3453
          srcType == GL_UNSIGNED_BYTE ||
3454
          srcType == GL_BYTE ||
3455
          srcType == GL_UNSIGNED_SHORT ||
3456
          srcType == GL_SHORT ||
3457
          srcType == GL_UNSIGNED_INT ||
3458
          srcType == GL_INT ||
3459
          srcType == GL_FLOAT);
3460
 
3461
   ASSERT(dstType == GL_UNSIGNED_BYTE ||
3462
          dstType == GL_UNSIGNED_SHORT ||
3463
          dstType == GL_UNSIGNED_INT);
3464
 
3465
   /* only shift and offset apply to stencil */
3466
   transferOps &= IMAGE_SHIFT_OFFSET_BIT;
3467
 
3468
   /*
3469
    * Try simple cases first
3470
    */
3471
   if (transferOps == 0 &&
3472
       srcType == GL_UNSIGNED_BYTE &&
3473
       dstType == GL_UNSIGNED_BYTE) {
3474
      MEMCPY(dest, source, n * sizeof(GLubyte));
3475
   }
3476
   else if (transferOps == 0 &&
3477
            srcType == GL_UNSIGNED_INT &&
3478
            dstType == GL_UNSIGNED_INT &&
3479
            !srcPacking->SwapBytes) {
3480
      MEMCPY(dest, source, n * sizeof(GLuint));
3481
   }
3482
   else {
3483
      /*
3484
       * general solution
3485
       */
3486
      GLuint indexes[MAX_WIDTH];
3487
      assert(n <= MAX_WIDTH);
3488
 
3489
      extract_uint_indexes(n, indexes, GL_COLOR_INDEX, srcType, source,
3490
                           srcPacking);
3491
 
3492
      if (transferOps) {
3493
         if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
3494
            /* shift and offset indexes */
3495
            _mesa_shift_and_offset_ci(ctx, n, indexes);
3496
         }
3497
 
3498
         if (ctx->Pixel.MapStencilFlag) {
3499
            /* Apply stencil lookup table */
3500
            GLuint mask = ctx->Pixel.MapStoSsize - 1;
3501
            GLuint i;
3502
            for (i=0;i<n;i++) {
3503
               indexes[i] = ctx->Pixel.MapStoS[ indexes[i] & mask ];
3504
            }
3505
         }
3506
      }
3507
 
3508
      /* convert to dest type */
3509
      switch (dstType) {
3510
         case GL_UNSIGNED_BYTE:
3511
            {
3512
               GLubyte *dst = (GLubyte *) dest;
3513
               GLuint i;
3514
               for (i = 0; i < n; i++) {
3515
                  dst[i] = (GLubyte) (indexes[i] & 0xff);
3516
               }
3517
            }
3518
            break;
3519
         case GL_UNSIGNED_SHORT:
3520
            {
3521
               GLuint *dst = (GLuint *) dest;
3522
               GLuint i;
3523
               for (i = 0; i < n; i++) {
3524
                  dst[i] = (GLushort) (indexes[i] & 0xffff);
3525
               }
3526
            }
3527
            break;
3528
         case GL_UNSIGNED_INT:
3529
            MEMCPY(dest, indexes, n * sizeof(GLuint));
3530
            break;
3531
         default:
3532
            _mesa_problem(ctx, "bad dstType in _mesa_unpack_stencil_span");
3533
      }
3534
   }
3535
}
3536
 
3537
 
3538
void
3539
_mesa_pack_stencil_span( const GLcontext *ctx, GLuint n,
3540
                         GLenum dstType, GLvoid *dest, const GLstencil *source,
3541
                         const struct gl_pixelstore_attrib *dstPacking )
3542
{
3543
   GLstencil stencil[MAX_WIDTH];
3544
 
3545
   ASSERT(n <= MAX_WIDTH);
3546
 
3547
   if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset ||
3548
       ctx->Pixel.MapStencilFlag) {
3549
      /* make a copy of input */
3550
      MEMCPY(stencil, source, n * sizeof(GLstencil));
3551
      if (ctx->Pixel.IndexShift || ctx->Pixel.IndexOffset) {
3552
         _mesa_shift_and_offset_stencil( ctx, n, stencil );
3553
      }
3554
      if (ctx->Pixel.MapStencilFlag) {
3555
         _mesa_map_stencil( ctx, n, stencil );
3556
      }
3557
      source = stencil;
3558
   }
3559
 
3560
   switch (dstType) {
3561
   case GL_UNSIGNED_BYTE:
3562
      if (sizeof(GLstencil) == 8) {
3563
         MEMCPY( dest, source, n );
3564
      }
3565
      else {
3566
         GLubyte *dst = (GLubyte *) dest;
3567
         GLuint i;
3568
         for (i=0;i<n;i++) {
3569
            dst[i] = (GLubyte) source[i];
3570
         }
3571
      }
3572
      break;
3573
   case GL_BYTE:
3574
      if (sizeof(GLstencil) == 8) {
3575
         MEMCPY( dest, source, n );
3576
      }
3577
      else {
3578
         GLbyte *dst = (GLbyte *) dest;
3579
         GLuint i;
3580
         for (i=0;i<n;i++) {
3581
            dst[i] = (GLbyte) source[i];
3582
         }
3583
      }
3584
      break;
3585
   case GL_UNSIGNED_SHORT:
3586
      {
3587
         GLushort *dst = (GLushort *) dest;
3588
         GLuint i;
3589
         for (i=0;i<n;i++) {
3590
            dst[i] = (GLushort) source[i];
3591
         }
3592
         if (dstPacking->SwapBytes) {
3593
            _mesa_swap2( (GLushort *) dst, n );
3594
         }
3595
      }
3596
      break;
3597
   case GL_SHORT:
3598
      {
3599
         GLshort *dst = (GLshort *) dest;
3600
         GLuint i;
3601
         for (i=0;i<n;i++) {
3602
            dst[i] = (GLshort) source[i];
3603
         }
3604
         if (dstPacking->SwapBytes) {
3605
            _mesa_swap2( (GLushort *) dst, n );
3606
         }
3607
      }
3608
      break;
3609
   case GL_UNSIGNED_INT:
3610
      {
3611
         GLuint *dst = (GLuint *) dest;
3612
         GLuint i;
3613
         for (i=0;i<n;i++) {
3614
            dst[i] = (GLuint) source[i];
3615
         }
3616
         if (dstPacking->SwapBytes) {
3617
            _mesa_swap4( (GLuint *) dst, n );
3618
         }
3619
      }
3620
      break;
3621
   case GL_INT:
3622
      {
3623
         GLint *dst = (GLint *) dest;
3624
         GLuint i;
3625
         for (i=0;i<n;i++) {
3626
            *dst++ = (GLint) source[i];
3627
         }
3628
         if (dstPacking->SwapBytes) {
3629
            _mesa_swap4( (GLuint *) dst, n );
3630
         }
3631
      }
3632
      break;
3633
   case GL_FLOAT:
3634
      {
3635
         GLfloat *dst = (GLfloat *) dest;
3636
         GLuint i;
3637
         for (i=0;i<n;i++) {
3638
            dst[i] = (GLfloat) source[i];
3639
         }
3640
         if (dstPacking->SwapBytes) {
3641
            _mesa_swap4( (GLuint *) dst, n );
3642
         }
3643
      }
3644
      break;
3645
   case GL_BITMAP:
3646
      if (dstPacking->LsbFirst) {
3647
         GLubyte *dst = (GLubyte *) dest;
3648
         GLint shift = 0;
3649
         GLuint i;
3650
         for (i = 0; i < n; i++) {
3651
            if (shift == 0)
3652
               *dst = 0;
3653
            *dst |= ((source[i] != 0) << shift);
3654
            shift++;
3655
            if (shift == 8) {
3656
               shift = 0;
3657
               dst++;
3658
            }
3659
         }
3660
      }
3661
      else {
3662
         GLubyte *dst = (GLubyte *) dest;
3663
         GLint shift = 7;
3664
         GLuint i;
3665
         for (i = 0; i < n; i++) {
3666
            if (shift == 7)
3667
               *dst = 0;
3668
            *dst |= ((source[i] != 0) << shift);
3669
            shift--;
3670
            if (shift < 0) {
3671
               shift = 7;
3672
               dst++;
3673
            }
3674
         }
3675
      }
3676
      break;
3677
   default:
3678
      _mesa_problem(ctx, "bad type in _mesa_pack_index_span");
3679
   }
3680
}
3681
 
3682
 
3683
 
3684
void
3685
_mesa_unpack_depth_span( const GLcontext *ctx, GLuint n, GLfloat *dest,
3686
                         GLenum srcType, const GLvoid *source,
3687
                         const struct gl_pixelstore_attrib *srcPacking )
3688
{
3689
   switch (srcType) {
3690
      case GL_BYTE:
3691
         {
3692
            GLuint i;
3693
            const GLubyte *src = (const GLubyte *) source;
3694
            for (i = 0; i < n; i++) {
3695
               dest[i] = BYTE_TO_FLOAT(src[i]);
3696
            }
3697
         }
3698
         break;
3699
      case GL_UNSIGNED_BYTE:
3700
         {
3701
            GLuint i;
3702
            const GLubyte *src = (const GLubyte *) source;
3703
            for (i = 0; i < n; i++) {
3704
               dest[i] = UBYTE_TO_FLOAT(src[i]);
3705
            }
3706
         }
3707
         break;
3708
      case GL_SHORT:
3709
         {
3710
            GLuint i;
3711
            const GLshort *src = (const GLshort *) source;
3712
            for (i = 0; i < n; i++) {
3713
               dest[i] = SHORT_TO_FLOAT(src[i]);
3714
            }
3715
         }
3716
         break;
3717
      case GL_UNSIGNED_SHORT:
3718
         {
3719
            GLuint i;
3720
            const GLushort *src = (const GLushort *) source;
3721
            for (i = 0; i < n; i++) {
3722
               dest[i] = USHORT_TO_FLOAT(src[i]);
3723
            }
3724
         }
3725
         break;
3726
      case GL_INT:
3727
         {
3728
            GLuint i;
3729
            const GLint *src = (const GLint *) source;
3730
            for (i = 0; i < n; i++) {
3731
               dest[i] = INT_TO_FLOAT(src[i]);
3732
            }
3733
         }
3734
         break;
3735
      case GL_UNSIGNED_INT:
3736
         {
3737
            GLuint i;
3738
            const GLuint *src = (const GLuint *) source;
3739
            for (i = 0; i < n; i++) {
3740
               dest[i] = UINT_TO_FLOAT(src[i]);
3741
            }
3742
         }
3743
         break;
3744
      case GL_FLOAT:
3745
         MEMCPY(dest, source, n * sizeof(GLfloat));
3746
         break;
3747
      default:
3748
         _mesa_problem(NULL, "bad type in _mesa_unpack_depth_span()");
3749
         return;
3750
   }
3751
 
3752
 
3753
   /* apply depth scale and bias and clamp to [0,1] */
3754
   if (ctx->Pixel.DepthScale != 1.0 || ctx->Pixel.DepthBias != 0.0) {
3755
      GLuint i;
3756
      for (i = 0; i < n; i++) {
3757
         GLfloat d = dest[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
3758
         dest[i] = CLAMP(d, 0.0F, 1.0F);
3759
      }
3760
   }
3761
}
3762
 
3763
 
3764
 
3765
/*
3766
 * Pack an array of depth values.  The values are floats in [0,1].
3767
 */
3768
void
3769
_mesa_pack_depth_span( const GLcontext *ctx, GLuint n, GLvoid *dest,
3770
                       GLenum dstType, const GLfloat *depthSpan,
3771
                       const struct gl_pixelstore_attrib *dstPacking )
3772
{
3773
   GLfloat depthCopy[MAX_WIDTH];
3774
   const GLboolean bias_or_scale = ctx->Pixel.DepthBias != 0.0 ||
3775
                                   ctx->Pixel.DepthScale != 1.0;
3776
 
3777
   ASSERT(n <= MAX_WIDTH);
3778
 
3779
   if (bias_or_scale) {
3780
      GLuint i;
3781
      for (i = 0; i < n; i++) {
3782
         GLfloat d;
3783
         d = depthSpan[i] * ctx->Pixel.DepthScale + ctx->Pixel.DepthBias;
3784
         depthCopy[i] = CLAMP(d, 0.0F, 1.0F);
3785
      }
3786
      depthSpan = depthCopy;
3787
   }
3788
 
3789
   switch (dstType) {
3790
   case GL_UNSIGNED_BYTE:
3791
      {
3792
         GLubyte *dst = (GLubyte *) dest;
3793
         GLuint i;
3794
         for (i = 0; i < n; i++) {
3795
            dst[i] = FLOAT_TO_UBYTE( depthSpan[i] );
3796
         }
3797
      }
3798
      break;
3799
   case GL_BYTE:
3800
      {
3801
         GLbyte *dst = (GLbyte *) dest;
3802
         GLuint i;
3803
         for (i = 0; i < n; i++) {
3804
            dst[i] = FLOAT_TO_BYTE( depthSpan[i] );
3805
         }
3806
      }
3807
      break;
3808
   case GL_UNSIGNED_SHORT:
3809
      {
3810
         GLushort *dst = (GLushort *) dest;
3811
         GLuint i;
3812
         for (i = 0; i < n; i++) {
3813
            dst[i] = FLOAT_TO_USHORT( depthSpan[i] );
3814
         }
3815
         if (dstPacking->SwapBytes) {
3816
            _mesa_swap2( (GLushort *) dst, n );
3817
         }
3818
      }
3819
      break;
3820
   case GL_SHORT:
3821
      {
3822
         GLshort *dst = (GLshort *) dest;
3823
         GLuint i;
3824
         for (i = 0; i < n; i++) {
3825
            dst[i] = FLOAT_TO_SHORT( depthSpan[i] );
3826
         }
3827
         if (dstPacking->SwapBytes) {
3828
            _mesa_swap2( (GLushort *) dst, n );
3829
         }
3830
      }
3831
      break;
3832
   case GL_UNSIGNED_INT:
3833
      {
3834
         GLuint *dst = (GLuint *) dest;
3835
         GLuint i;
3836
         for (i = 0; i < n; i++) {
3837
            dst[i] = FLOAT_TO_UINT( depthSpan[i] );
3838
         }
3839
         if (dstPacking->SwapBytes) {
3840
            _mesa_swap4( (GLuint *) dst, n );
3841
         }
3842
      }
3843
      break;
3844
   case GL_INT:
3845
      {
3846
         GLint *dst = (GLint *) dest;
3847
         GLuint i;
3848
         for (i = 0; i < n; i++) {
3849
            dst[i] = FLOAT_TO_INT( depthSpan[i] );
3850
         }
3851
         if (dstPacking->SwapBytes) {
3852
            _mesa_swap4( (GLuint *) dst, n );
3853
         }
3854
      }
3855
      break;
3856
   case GL_FLOAT:
3857
      {
3858
         GLfloat *dst = (GLfloat *) dest;
3859
         GLuint i;
3860
         for (i = 0; i < n; i++) {
3861
            dst[i] = depthSpan[i];
3862
         }
3863
         if (dstPacking->SwapBytes) {
3864
            _mesa_swap4( (GLuint *) dst, n );
3865
         }
3866
      }
3867
      break;
3868
   default:
3869
      _mesa_problem(ctx, "bad type in _mesa_pack_depth_span");
3870
   }
3871
}
3872
 
3873
 
3874
 
3875
 
3876
/*
3877
 * Unpack image data.  Apply byteswapping, byte flipping (bitmap).
3878
 * Return all image data in a contiguous block.
3879
 */
3880
void *
3881
_mesa_unpack_image( GLsizei width, GLsizei height, GLsizei depth,
3882
                    GLenum format, GLenum type, const GLvoid *pixels,
3883
                    const struct gl_pixelstore_attrib *unpack )
3884
{
3885
   GLint bytesPerRow, compsPerRow;
3886
   GLboolean flipBytes, swap2, swap4;
3887
 
3888
   if (!pixels)
3889
      return NULL;  /* not necessarily an error */
3890
 
3891
   if (width <= 0 || height <= 0 || depth <= 0)
3892
      return NULL;  /* generate error later */
3893
 
3894
   if (format == GL_BITMAP) {
3895
      bytesPerRow = (width + 7) >> 3;
3896
      flipBytes = !unpack->LsbFirst;
3897
      swap2 = swap4 = GL_FALSE;
3898
      compsPerRow = 0;
3899
   }
3900
   else {
3901
      const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type);
3902
      const GLint components = _mesa_components_in_format(format);
3903
      GLint bytesPerComp;
3904
      if (bytesPerPixel <= 0 || components <= 0)
3905
         return NULL;   /* bad format or type.  generate error later */
3906
      bytesPerRow = bytesPerPixel * width;
3907
      bytesPerComp = bytesPerPixel / components;
3908
      flipBytes = GL_FALSE;
3909
      swap2 = (bytesPerComp == 2) && unpack->SwapBytes;
3910
      swap4 = (bytesPerComp == 4) && unpack->SwapBytes;
3911
      compsPerRow = components * width;
3912
      assert(compsPerRow >= width);
3913
   }
3914
 
3915
   {
3916
      GLubyte *destBuffer = (GLubyte *) MALLOC(bytesPerRow * height * depth);
3917
      GLubyte *dst;
3918
      GLint img, row;
3919
      if (!destBuffer)
3920
         return NULL;   /* generate GL_OUT_OF_MEMORY later */
3921
 
3922
      dst = destBuffer;
3923
      for (img = 0; img < depth; img++) {
3924
         for (row = 0; row < height; row++) {
3925
            const GLvoid *src = _mesa_image_address(unpack, pixels,
3926
                               width, height, format, type, img, row, 0);
3927
            MEMCPY(dst, src, bytesPerRow);
3928
            /* byte flipping/swapping */
3929
            if (flipBytes) {
3930
               flip_bytes((GLubyte *) dst, bytesPerRow);
3931
            }
3932
            else if (swap2) {
3933
               _mesa_swap2((GLushort*) dst, compsPerRow);
3934
            }
3935
            else if (swap4) {
3936
               _mesa_swap4((GLuint*) dst, compsPerRow);
3937
            }
3938
            dst += bytesPerRow;
3939
         }
3940
      }
3941
      return destBuffer;
3942
   }
3943
}