GLES_common/yagl_gles_pixel_formats.c

   1 /*
   2  * YaGL
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact :
   7  * Stanislav Vorobiov <s.vorobiov@samsung.com>
   8  * Jinhyung Jo <jinhyung.jo@samsung.com>
   9  * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  27  * THE SOFTWARE.
  28  *
  29  * Contributors:
  30  * - S-Core Co., Ltd
  31  *
  32  */
  33
  34 #include "GL/gl.h"
  35 #include "GL/glext.h"
  36 #include "yagl_gles_pixel_formats.h"
  37
  38 /*
  39  * We can't include GLES2/gl2ext.h here
  40  */
  41 #define GL_HALF_FLOAT_OES 0x8D61
  42
  43 /*
  44  * 1.0f in half-float.
  45  */
  46 #define YAGL_HALF_FLOAT_1_0 0x3C00
  47
  48 static void yagl_convert_alpha_ub_bgra_ub(const GLvoid *src,
  49                                           GLsizei src_stride,
  50                                           GLvoid *dst,
  51                                           GLsizei dst_stride,
  52                                           GLsizei width,
  53                                           GLsizei height)
  54 {
  55     GLsizei i, j;
  56
  57     for (i = 0; i < height; ++i) {
  58         for (j = 0; j < width; ++j) {
  59             *(uint32_t*)(dst + j * 4) = ((uint32_t)(*(uint8_t*)(src + j)) << 24);
  60         }
  61         src += src_stride;
  62         dst += dst_stride;
  63     }
  64 }
  65
  66 static void yagl_convert_bgra_ub_alpha_ub(const GLvoid *src,
  67                                           GLsizei src_stride,
  68                                           GLvoid *dst,
  69                                           GLsizei dst_stride,
  70                                           GLsizei width,
  71                                           GLsizei height)
  72 {
  73     GLsizei i, j;
  74
  75     for (i = 0; i < height; ++i) {
  76         for (j = 0; j < width; ++j) {
  77             *(uint8_t*)(dst + j) = *(uint32_t*)(src + j * 4) >> 24;
  78         }
  79         src += src_stride;
  80         dst += dst_stride;
  81     }
  82 }
  83
  84 static void yagl_convert_alpha_f_bgra_f(const GLvoid *src,
  85                                         GLsizei src_stride,
  86                                         GLvoid *dst,
  87                                         GLsizei dst_stride,
  88                                         GLsizei width,
  89                                         GLsizei height)
  90 {
  91     GLsizei i, j;
  92
  93     for (i = 0; i < height; ++i) {
  94         for (j = 0; j < width; ++j) {
  95             *(GLfloat*)(dst + j * 16 + 0) = 0.0f;
  96             *(GLfloat*)(dst + j * 16 + 4) = 0.0f;
  97             *(GLfloat*)(dst + j * 16 + 8) = 0.0f;
  98             *(uint32_t*)(dst + j * 16 + 12) = *(uint32_t*)(src + j * 4);
  99         }
 100         src += src_stride;
 101         dst += dst_stride;
 102     }
 103 }
 104
 105 static void yagl_convert_bgra_f_alpha_f(const GLvoid *src,
 106                                         GLsizei src_stride,
 107                                         GLvoid *dst,
 108                                         GLsizei dst_stride,
 109                                         GLsizei width,
 110                                         GLsizei height)
 111 {
 112     GLsizei i, j;
 113
 114     for (i = 0; i < height; ++i) {
 115         for (j = 0; j < width; ++j) {
 116             *(uint32_t*)(dst + j * 4) = *(uint32_t*)(src + j * 16 + 12);
 117         }
 118         src += src_stride;
 119         dst += dst_stride;
 120     }
 121 }
 122
 123 static void yagl_convert_alpha_hf_bgra_hf(const GLvoid *src,
 124                                           GLsizei src_stride,
 125                                           GLvoid *dst,
 126                                           GLsizei dst_stride,
 127                                           GLsizei width,
 128                                           GLsizei height)
 129 {
 130     GLsizei i, j;
 131
 132     for (i = 0; i < height; ++i) {
 133         for (j = 0; j < width; ++j) {
 134             *(uint16_t*)(dst + j * 8 + 0) = 0;
 135             *(uint16_t*)(dst + j * 8 + 2) = 0;
 136             *(uint16_t*)(dst + j * 8 + 4) = 0;
 137             *(uint16_t*)(dst + j * 8 + 6) = *(uint16_t*)(src + j * 2);
 138         }
 139         src += src_stride;
 140         dst += dst_stride;
 141     }
 142 }
 143
 144 static void yagl_convert_bgra_hf_alpha_hf(const GLvoid *src,
 145                                           GLsizei src_stride,
 146                                           GLvoid *dst,
 147                                           GLsizei dst_stride,
 148                                           GLsizei width,
 149                                           GLsizei height)
 150 {
 151     GLsizei i, j;
 152
 153     for (i = 0; i < height; ++i) {
 154         for (j = 0; j < width; ++j) {
 155             *(uint16_t*)(dst + j * 2) = *(uint16_t*)(src + j * 8 + 6);
 156         }
 157         src += src_stride;
 158         dst += dst_stride;
 159     }
 160 }
 161
 162 static void yagl_convert_luminance_ub_bgra_ub(const GLvoid *src,
 163                                               GLsizei src_stride,
 164                                               GLvoid *dst,
 165                                               GLsizei dst_stride,
 166                                               GLsizei width,
 167                                               GLsizei height)
 168 {
 169     GLsizei i, j;
 170
 171     for (i = 0; i < height; ++i) {
 172         for (j = 0; j < width; ++j) {
 173             uint32_t l = *(uint8_t*)(src + j);
 174             *(uint32_t*)(dst + j * 4) = (l << 0) |
 175                                         (l << 8) |
 176                                         (l << 16) |
 177                                         (255U << 24);
 178         }
 179         src += src_stride;
 180         dst += dst_stride;
 181     }
 182 }
 183
 184 static void yagl_convert_bgra_ub_luminance_ub(const GLvoid *src,
 185                                               GLsizei src_stride,
 186                                               GLvoid *dst,
 187                                               GLsizei dst_stride,
 188                                               GLsizei width,
 189                                               GLsizei height)
 190 {
 191     GLsizei i, j;
 192
 193     for (i = 0; i < height; ++i) {
 194         for (j = 0; j < width; ++j) {
 195             *(uint8_t*)(dst + j) = *(uint32_t*)(src + j * 4) & 0xFF;
 196         }
 197         src += src_stride;
 198         dst += dst_stride;
 199     }
 200 }
 201
 202 static void yagl_convert_luminance_f_bgra_f(const GLvoid *src,
 203                                             GLsizei src_stride,
 204                                             GLvoid *dst,
 205                                             GLsizei dst_stride,
 206                                             GLsizei width,
 207                                             GLsizei height)
 208 {
 209     GLsizei i, j;
 210
 211     for (i = 0; i < height; ++i) {
 212         for (j = 0; j < width; ++j) {
 213             uint32_t l = *(uint32_t*)(src + j * 4);
 214             *(uint32_t*)(dst + j * 16 + 0) = l;
 215             *(uint32_t*)(dst + j * 16 + 4) = l;
 216             *(uint32_t*)(dst + j * 16 + 8) = l;
 217             *(GLfloat*)(dst + j * 16 + 12) = 1.0f;
 218         }
 219         src += src_stride;
 220         dst += dst_stride;
 221     }
 222 }
 223
 224 static void yagl_convert_bgra_f_luminance_f(const GLvoid *src,
 225                                             GLsizei src_stride,
 226                                             GLvoid *dst,
 227                                             GLsizei dst_stride,
 228                                             GLsizei width,
 229                                             GLsizei height)
 230 {
 231     GLsizei i, j;
 232
 233     for (i = 0; i < height; ++i) {
 234         for (j = 0; j < width; ++j) {
 235             *(uint32_t*)(dst + j * 4) = *(uint32_t*)(src + j * 16);
 236         }
 237         src += src_stride;
 238         dst += dst_stride;
 239     }
 240 }
 241
 242 static void yagl_convert_luminance_hf_bgra_hf(const GLvoid *src,
 243                                               GLsizei src_stride,
 244                                               GLvoid *dst,
 245                                               GLsizei dst_stride,
 246                                               GLsizei width,
 247                                               GLsizei height)
 248 {
 249     GLsizei i, j;
 250
 251     for (i = 0; i < height; ++i) {
 252         for (j = 0; j < width; ++j) {
 253             uint16_t l = *(uint16_t*)(src + j * 2);
 254             *(uint16_t*)(dst + j * 8 + 0) = l;
 255             *(uint16_t*)(dst + j * 8 + 2) = l;
 256             *(uint16_t*)(dst + j * 8 + 4) = l;
 257             *(uint16_t*)(dst + j * 8 + 6) = YAGL_HALF_FLOAT_1_0;
 258         }
 259         src += src_stride;
 260         dst += dst_stride;
 261     }
 262 }
 263
 264 static void yagl_convert_bgra_hf_luminance_hf(const GLvoid *src,
 265                                               GLsizei src_stride,
 266                                               GLvoid *dst,
 267                                               GLsizei dst_stride,
 268                                               GLsizei width,
 269                                               GLsizei height)
 270 {
 271     GLsizei i, j;
 272
 273     for (i = 0; i < height; ++i) {
 274         for (j = 0; j < width; ++j) {
 275             *(uint16_t*)(dst + j * 2) = *(uint16_t*)(src + j * 8);
 276         }
 277         src += src_stride;
 278         dst += dst_stride;
 279     }
 280 }
 281
 282 static void yagl_convert_luminance_alpha_ub_bgra_ub(const GLvoid *src,
 283                                                     GLsizei src_stride,
 284                                                     GLvoid *dst,
 285                                                     GLsizei dst_stride,
 286                                                     GLsizei width,
 287                                                     GLsizei height)
 288 {
 289     GLsizei i, j;
 290
 291     for (i = 0; i < height; ++i) {
 292         for (j = 0; j < width; ++j) {
 293             uint32_t l = *(uint8_t*)(src + j * 2 + 0);
 294             uint32_t a = *(uint8_t*)(src + j * 2 + 1);
 295             *(uint32_t*)(dst + j * 4) = (l << 0) |
 296                                         (l << 8) |
 297                                         (l << 16) |
 298                                         (a << 24);
 299         }
 300         src += src_stride;
 301         dst += dst_stride;
 302     }
 303 }
 304
 305 static void yagl_convert_bgra_ub_luminance_alpha_ub(const GLvoid *src,
 306                                                     GLsizei src_stride,
 307                                                     GLvoid *dst,
 308                                                     GLsizei dst_stride,
 309                                                     GLsizei width,
 310                                                     GLsizei height)
 311 {
 312     GLsizei i, j;
 313
 314     for (i = 0; i < height; ++i) {
 315         for (j = 0; j < width; ++j) {
 316             *(uint8_t*)(dst + j * 2 + 0) = *(uint32_t*)(src + j * 4) & 0xFF;
 317             *(uint8_t*)(dst + j * 2 + 1) = *(uint32_t*)(src + j * 4) >> 24;
 318         }
 319         src += src_stride;
 320         dst += dst_stride;
 321     }
 322 }
 323
 324 static void yagl_convert_luminance_alpha_f_bgra_f(const GLvoid *src,
 325                                                   GLsizei src_stride,
 326                                                   GLvoid *dst,
 327                                                   GLsizei dst_stride,
 328                                                   GLsizei width,
 329                                                   GLsizei height)
 330 {
 331     GLsizei i, j;
 332
 333     for (i = 0; i < height; ++i) {
 334         for (j = 0; j < width; ++j) {
 335             uint32_t l = *(uint32_t*)(src + j * 8 + 0);
 336             uint32_t a = *(uint32_t*)(src + j * 8 + 4);
 337             *(uint32_t*)(dst + j * 16 + 0) = l;
 338             *(uint32_t*)(dst + j * 16 + 4) = l;
 339             *(uint32_t*)(dst + j * 16 + 8) = l;
 340             *(uint32_t*)(dst + j * 16 + 12) = a;
 341         }
 342         src += src_stride;
 343         dst += dst_stride;
 344     }
 345 }
 346
 347 static void yagl_convert_bgra_f_luminance_alpha_f(const GLvoid *src,
 348                                                   GLsizei src_stride,
 349                                                   GLvoid *dst,
 350                                                   GLsizei dst_stride,
 351                                                   GLsizei width,
 352                                                   GLsizei height)
 353 {
 354     GLsizei i, j;
 355
 356     for (i = 0; i < height; ++i) {
 357         for (j = 0; j < width; ++j) {
 358             *(uint32_t*)(dst + j * 8 + 0) = *(uint32_t*)(src + j * 16);
 359             *(uint32_t*)(dst + j * 8 + 4) = *(uint32_t*)(src + j * 16 + 12);
 360         }
 361         src += src_stride;
 362         dst += dst_stride;
 363     }
 364 }
 365
 366 static void yagl_convert_luminance_alpha_hf_bgra_hf(const GLvoid *src,
 367                                                     GLsizei src_stride,
 368                                                     GLvoid *dst,
 369                                                     GLsizei dst_stride,
 370                                                     GLsizei width,
 371                                                     GLsizei height)
 372 {
 373     GLsizei i, j;
 374
 375     for (i = 0; i < height; ++i) {
 376         for (j = 0; j < width; ++j) {
 377             uint16_t l = *(uint16_t*)(src + j * 4 + 0);
 378             uint16_t a = *(uint16_t*)(src + j * 4 + 2);
 379             *(uint16_t*)(dst + j * 8 + 0) = l;
 380             *(uint16_t*)(dst + j * 8 + 2) = l;
 381             *(uint16_t*)(dst + j * 8 + 4) = l;
 382             *(uint16_t*)(dst + j * 8 + 6) = a;
 383         }
 384         src += src_stride;
 385         dst += dst_stride;
 386     }
 387 }
 388
 389 static void yagl_convert_bgra_hf_luminance_alpha_hf(const GLvoid *src,
 390                                                     GLsizei src_stride,
 391                                                     GLvoid *dst,
 392                                                     GLsizei dst_stride,
 393                                                     GLsizei width,
 394                                                     GLsizei height)
 395 {
 396     GLsizei i, j;
 397
 398     for (i = 0; i < height; ++i) {
 399         for (j = 0; j < width; ++j) {
 400             *(uint16_t*)(dst + j * 4 + 0) = *(uint16_t*)(src + j * 8);
 401             *(uint16_t*)(dst + j * 4 + 2) = *(uint16_t*)(src + j * 8 + 6);
 402         }
 403         src += src_stride;
 404         dst += dst_stride;
 405     }
 406 }
 407
 408 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE, GL_ALPHA, GL_UNSIGNED_BYTE, 1);
 409 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_ALPHA, GL_ALPHA, GL_FLOAT, GL_ALPHA32F_ARB, GL_FLOAT, 4);
 410 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_ALPHA, GL_ALPHA, GL_HALF_FLOAT, GL_ALPHA, GL_HALF_FLOAT, 2);
 411 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_ALPHA, GL_ALPHA, GL_HALF_FLOAT_OES, GL_ALPHA, GL_HALF_FLOAT, 2);
 412
 413 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE)
 414     .src_bpp = 1,
 415     .dst_internalformat = GL_RGBA,
 416     .dst_format = GL_BGRA,
 417     .dst_type = GL_UNSIGNED_BYTE,
 418     .dst_bpp = 4,
 419     .unpack = &yagl_convert_alpha_ub_bgra_ub,
 420     .pack = &yagl_convert_bgra_ub_alpha_ub
 421 YAGL_PIXEL_FORMAT_IMPL_END()
 422
 423 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_ALPHA, GL_ALPHA, GL_FLOAT)
 424     .src_bpp = 4,
 425     .dst_internalformat = GL_RGBA,
 426     .dst_format = GL_BGRA,
 427     .dst_type = GL_FLOAT,
 428     .dst_bpp = 16,
 429     .unpack = &yagl_convert_alpha_f_bgra_f,
 430     .pack = &yagl_convert_bgra_f_alpha_f
 431 YAGL_PIXEL_FORMAT_IMPL_END()
 432
 433 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_ALPHA, GL_ALPHA, GL_HALF_FLOAT)
 434     .src_bpp = 2,
 435     .dst_internalformat = GL_RGBA,
 436     .dst_format = GL_BGRA,
 437     .dst_type = GL_HALF_FLOAT,
 438     .dst_bpp = 8,
 439     .unpack = &yagl_convert_alpha_hf_bgra_hf,
 440     .pack = &yagl_convert_bgra_hf_alpha_hf
 441 YAGL_PIXEL_FORMAT_IMPL_END()
 442
 443 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_ALPHA, GL_ALPHA, GL_HALF_FLOAT_OES)
 444     .src_bpp = 2,
 445     .dst_internalformat = GL_RGBA,
 446     .dst_format = GL_BGRA,
 447     .dst_type = GL_HALF_FLOAT,
 448     .dst_bpp = 8,
 449     .unpack = &yagl_convert_alpha_hf_bgra_hf,
 450     .pack = &yagl_convert_bgra_hf_alpha_hf
 451 YAGL_PIXEL_FORMAT_IMPL_END()
 452
 453 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, GL_RGB, GL_UNSIGNED_BYTE, 3);
 454 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 2);
 455 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGB, GL_RGB, GL_FLOAT, GL_RGB32F, GL_FLOAT, 12);
 456 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGB, GL_RGB, GL_HALF_FLOAT, GL_RGB, GL_HALF_FLOAT, 6);
 457 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGB, GL_RGB, GL_HALF_FLOAT_OES, GL_RGB, GL_HALF_FLOAT, 6);
 458 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, GL_RGBA, GL_UNSIGNED_BYTE, 4);
 459 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 2);
 460 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, 2);
 461 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGBA, GL_RGBA, GL_FLOAT, GL_RGBA32F, GL_FLOAT, 16);
 462 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGBA, GL_RGBA, GL_HALF_FLOAT, GL_RGBA, GL_HALF_FLOAT, 8);
 463 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_RGBA, GL_RGBA, GL_HALF_FLOAT_OES, GL_RGBA, GL_HALF_FLOAT, 8);
 464 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_BGRA, GL_BGRA, GL_UNSIGNED_BYTE, GL_RGBA, GL_UNSIGNED_BYTE, 4);
 465 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_BGRA, GL_BGRA, GL_FLOAT, GL_RGBA32F, GL_FLOAT, 16);
 466 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_BGRA, GL_BGRA, GL_HALF_FLOAT, GL_RGBA, GL_HALF_FLOAT, 8);
 467 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_BGRA, GL_BGRA, GL_HALF_FLOAT_OES, GL_RGBA, GL_HALF_FLOAT, 8);
 468 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE, GL_LUMINANCE, GL_UNSIGNED_BYTE, 1);
 469 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_LUMINANCE, GL_LUMINANCE, GL_FLOAT, GL_LUMINANCE32F_ARB, GL_FLOAT, 4);
 470 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_LUMINANCE, GL_LUMINANCE, GL_HALF_FLOAT, GL_LUMINANCE, GL_HALF_FLOAT, 2);
 471 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_LUMINANCE, GL_LUMINANCE, GL_HALF_FLOAT_OES, GL_LUMINANCE, GL_HALF_FLOAT, 2);
 472 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 2);
 473 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_FLOAT, GL_LUMINANCE_ALPHA32F_ARB, GL_FLOAT, 8);
 474 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT, 4);
 475 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles_gl2, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT, 4);
 476
 477 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE)
 478     .src_bpp = 1,
 479     .dst_internalformat = GL_RGBA,
 480     .dst_format = GL_BGRA,
 481     .dst_type = GL_UNSIGNED_BYTE,
 482     .dst_bpp = 4,
 483     .unpack = &yagl_convert_luminance_ub_bgra_ub,
 484     .pack = &yagl_convert_bgra_ub_luminance_ub
 485 YAGL_PIXEL_FORMAT_IMPL_END()
 486
 487 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_LUMINANCE, GL_LUMINANCE, GL_FLOAT)
 488     .src_bpp = 4,
 489     .dst_internalformat = GL_RGBA,
 490     .dst_format = GL_BGRA,
 491     .dst_type = GL_FLOAT,
 492     .dst_bpp = 16,
 493     .unpack = &yagl_convert_luminance_f_bgra_f,
 494     .pack = &yagl_convert_bgra_f_luminance_f
 495 YAGL_PIXEL_FORMAT_IMPL_END()
 496
 497 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_LUMINANCE, GL_LUMINANCE, GL_HALF_FLOAT)
 498     .src_bpp = 2,
 499     .dst_internalformat = GL_RGBA,
 500     .dst_format = GL_BGRA,
 501     .dst_type = GL_HALF_FLOAT,
 502     .dst_bpp = 8,
 503     .unpack = &yagl_convert_luminance_hf_bgra_hf,
 504     .pack = &yagl_convert_bgra_hf_luminance_hf
 505 YAGL_PIXEL_FORMAT_IMPL_END()
 506
 507 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_LUMINANCE, GL_LUMINANCE, GL_HALF_FLOAT_OES)
 508     .src_bpp = 2,
 509     .dst_internalformat = GL_RGBA,
 510     .dst_format = GL_BGRA,
 511     .dst_type = GL_HALF_FLOAT,
 512     .dst_bpp = 8,
 513     .unpack = &yagl_convert_luminance_hf_bgra_hf,
 514     .pack = &yagl_convert_bgra_hf_luminance_hf
 515 YAGL_PIXEL_FORMAT_IMPL_END()
 516
 517 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE)
 518     .src_bpp = 2,
 519     .dst_internalformat = GL_RGBA,
 520     .dst_format = GL_BGRA,
 521     .dst_type = GL_UNSIGNED_BYTE,
 522     .dst_bpp = 4,
 523     .unpack = &yagl_convert_luminance_alpha_ub_bgra_ub,
 524     .pack = &yagl_convert_bgra_ub_luminance_alpha_ub
 525 YAGL_PIXEL_FORMAT_IMPL_END()
 526
 527 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_FLOAT)
 528     .src_bpp = 8,
 529     .dst_internalformat = GL_RGBA,
 530     .dst_format = GL_BGRA,
 531     .dst_type = GL_FLOAT,
 532     .dst_bpp = 16,
 533     .unpack = &yagl_convert_luminance_alpha_f_bgra_f,
 534     .pack = &yagl_convert_bgra_f_luminance_alpha_f
 535 YAGL_PIXEL_FORMAT_IMPL_END()
 536
 537 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT)
 538     .src_bpp = 4,
 539     .dst_internalformat = GL_RGBA,
 540     .dst_format = GL_BGRA,
 541     .dst_type = GL_HALF_FLOAT,
 542     .dst_bpp = 8,
 543     .unpack = &yagl_convert_luminance_alpha_hf_bgra_hf,
 544     .pack = &yagl_convert_bgra_hf_luminance_alpha_hf
 545 YAGL_PIXEL_FORMAT_IMPL_END()
 546
 547 YAGL_PIXEL_FORMAT_IMPL_BEGIN(gles_gl3, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES)
 548     .src_bpp = 4,
 549     .dst_internalformat = GL_RGBA,
 550     .dst_format = GL_BGRA,
 551     .dst_type = GL_HALF_FLOAT,
 552     .dst_bpp = 8,
 553     .unpack = &yagl_convert_luminance_alpha_hf_bgra_hf,
 554     .pack = &yagl_convert_bgra_hf_luminance_alpha_hf
 555 YAGL_PIXEL_FORMAT_IMPL_END()
 556
 557 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 2);
 558 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 4);
 559 YAGL_PIXEL_FORMAT_IMPL_NOCONV(gles, GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 4);