1 /*
2 * Copyright 2013 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 *
23 * Authors:
24 * Francisco Jerez <currojerez@riseup.net>
25 */
26
27 #include <assert.h>
28
29 #include "shaderimage.h"
30 #include "mtypes.h"
31 #include "formats.h"
32 #include "errors.h"
33 #include "hash.h"
34 #include "context.h"
35 #include "texobj.h"
36 #include "teximage.h"
37 #include "enums.h"
38
39 mesa_format
_mesa_get_shader_image_format(GLenum format)40 _mesa_get_shader_image_format(GLenum format)
41 {
42 switch (format) {
43 case GL_RGBA32F:
44 return MESA_FORMAT_RGBA_FLOAT32;
45
46 case GL_RGBA16F:
47 return MESA_FORMAT_RGBA_FLOAT16;
48
49 case GL_RG32F:
50 return MESA_FORMAT_RG_FLOAT32;
51
52 case GL_RG16F:
53 return MESA_FORMAT_RG_FLOAT16;
54
55 case GL_R11F_G11F_B10F:
56 return MESA_FORMAT_R11G11B10_FLOAT;
57
58 case GL_R32F:
59 return MESA_FORMAT_R_FLOAT32;
60
61 case GL_R16F:
62 return MESA_FORMAT_R_FLOAT16;
63
64 case GL_RGBA32UI:
65 return MESA_FORMAT_RGBA_UINT32;
66
67 case GL_RGBA16UI:
68 return MESA_FORMAT_RGBA_UINT16;
69
70 case GL_RGB10_A2UI:
71 return MESA_FORMAT_R10G10B10A2_UINT;
72
73 case GL_RGBA8UI:
74 return MESA_FORMAT_RGBA_UINT8;
75
76 case GL_RG32UI:
77 return MESA_FORMAT_RG_UINT32;
78
79 case GL_RG16UI:
80 return MESA_FORMAT_RG_UINT16;
81
82 case GL_RG8UI:
83 return MESA_FORMAT_RG_UINT8;
84
85 case GL_R32UI:
86 return MESA_FORMAT_R_UINT32;
87
88 case GL_R16UI:
89 return MESA_FORMAT_R_UINT16;
90
91 case GL_R8UI:
92 return MESA_FORMAT_R_UINT8;
93
94 case GL_RGBA32I:
95 return MESA_FORMAT_RGBA_SINT32;
96
97 case GL_RGBA16I:
98 return MESA_FORMAT_RGBA_SINT16;
99
100 case GL_RGBA8I:
101 return MESA_FORMAT_RGBA_SINT8;
102
103 case GL_RG32I:
104 return MESA_FORMAT_RG_SINT32;
105
106 case GL_RG16I:
107 return MESA_FORMAT_RG_SINT16;
108
109 case GL_RG8I:
110 return MESA_FORMAT_RG_SINT8;
111
112 case GL_R32I:
113 return MESA_FORMAT_R_SINT32;
114
115 case GL_R16I:
116 return MESA_FORMAT_R_SINT16;
117
118 case GL_R8I:
119 return MESA_FORMAT_R_SINT8;
120
121 case GL_RGBA16:
122 return MESA_FORMAT_RGBA_UNORM16;
123
124 case GL_RGB10_A2:
125 return MESA_FORMAT_R10G10B10A2_UNORM;
126
127 case GL_RGBA8:
128 return MESA_FORMAT_RGBA_UNORM8;
129
130 case GL_RG16:
131 return MESA_FORMAT_RG_UNORM16;
132
133 case GL_RG8:
134 return MESA_FORMAT_RG_UNORM8;
135
136 case GL_R16:
137 return MESA_FORMAT_R_UNORM16;
138
139 case GL_R8:
140 return MESA_FORMAT_R_UNORM8;
141
142 case GL_RGBA16_SNORM:
143 return MESA_FORMAT_RGBA_SNORM16;
144
145 case GL_RGBA8_SNORM:
146 return MESA_FORMAT_RGBA_SNORM8;
147
148 case GL_RG16_SNORM:
149 return MESA_FORMAT_RG_SNORM16;
150
151 case GL_RG8_SNORM:
152 return MESA_FORMAT_RG_SNORM8;
153
154 case GL_R16_SNORM:
155 return MESA_FORMAT_R_SNORM16;
156
157 case GL_R8_SNORM:
158 return MESA_FORMAT_R_SNORM8;
159
160 default:
161 return MESA_FORMAT_NONE;
162 }
163 }
164
165 enum image_format_class
166 {
167 /** Not a valid image format. */
168 IMAGE_FORMAT_CLASS_NONE = 0,
169
170 /** Classes of image formats you can cast into each other. */
171 /** \{ */
172 IMAGE_FORMAT_CLASS_1X8,
173 IMAGE_FORMAT_CLASS_1X16,
174 IMAGE_FORMAT_CLASS_1X32,
175 IMAGE_FORMAT_CLASS_2X8,
176 IMAGE_FORMAT_CLASS_2X16,
177 IMAGE_FORMAT_CLASS_2X32,
178 IMAGE_FORMAT_CLASS_10_11_11,
179 IMAGE_FORMAT_CLASS_4X8,
180 IMAGE_FORMAT_CLASS_4X16,
181 IMAGE_FORMAT_CLASS_4X32,
182 IMAGE_FORMAT_CLASS_2_10_10_10
183 /** \} */
184 };
185
186 static enum image_format_class
get_image_format_class(mesa_format format)187 get_image_format_class(mesa_format format)
188 {
189 switch (format) {
190 case MESA_FORMAT_RGBA_FLOAT32:
191 return IMAGE_FORMAT_CLASS_4X32;
192
193 case MESA_FORMAT_RGBA_FLOAT16:
194 return IMAGE_FORMAT_CLASS_4X16;
195
196 case MESA_FORMAT_RG_FLOAT32:
197 return IMAGE_FORMAT_CLASS_2X32;
198
199 case MESA_FORMAT_RG_FLOAT16:
200 return IMAGE_FORMAT_CLASS_2X16;
201
202 case MESA_FORMAT_R11G11B10_FLOAT:
203 return IMAGE_FORMAT_CLASS_10_11_11;
204
205 case MESA_FORMAT_R_FLOAT32:
206 return IMAGE_FORMAT_CLASS_1X32;
207
208 case MESA_FORMAT_R_FLOAT16:
209 return IMAGE_FORMAT_CLASS_1X16;
210
211 case MESA_FORMAT_RGBA_UINT32:
212 return IMAGE_FORMAT_CLASS_4X32;
213
214 case MESA_FORMAT_RGBA_UINT16:
215 return IMAGE_FORMAT_CLASS_4X16;
216
217 case MESA_FORMAT_R10G10B10A2_UINT:
218 return IMAGE_FORMAT_CLASS_2_10_10_10;
219
220 case MESA_FORMAT_RGBA_UINT8:
221 return IMAGE_FORMAT_CLASS_4X8;
222
223 case MESA_FORMAT_RG_UINT32:
224 return IMAGE_FORMAT_CLASS_2X32;
225
226 case MESA_FORMAT_RG_UINT16:
227 return IMAGE_FORMAT_CLASS_2X16;
228
229 case MESA_FORMAT_RG_UINT8:
230 return IMAGE_FORMAT_CLASS_2X8;
231
232 case MESA_FORMAT_R_UINT32:
233 return IMAGE_FORMAT_CLASS_1X32;
234
235 case MESA_FORMAT_R_UINT16:
236 return IMAGE_FORMAT_CLASS_1X16;
237
238 case MESA_FORMAT_R_UINT8:
239 return IMAGE_FORMAT_CLASS_1X8;
240
241 case MESA_FORMAT_RGBA_SINT32:
242 return IMAGE_FORMAT_CLASS_4X32;
243
244 case MESA_FORMAT_RGBA_SINT16:
245 return IMAGE_FORMAT_CLASS_4X16;
246
247 case MESA_FORMAT_RGBA_SINT8:
248 return IMAGE_FORMAT_CLASS_4X8;
249
250 case MESA_FORMAT_RG_SINT32:
251 return IMAGE_FORMAT_CLASS_2X32;
252
253 case MESA_FORMAT_RG_SINT16:
254 return IMAGE_FORMAT_CLASS_2X16;
255
256 case MESA_FORMAT_RG_SINT8:
257 return IMAGE_FORMAT_CLASS_2X8;
258
259 case MESA_FORMAT_R_SINT32:
260 return IMAGE_FORMAT_CLASS_1X32;
261
262 case MESA_FORMAT_R_SINT16:
263 return IMAGE_FORMAT_CLASS_1X16;
264
265 case MESA_FORMAT_R_SINT8:
266 return IMAGE_FORMAT_CLASS_1X8;
267
268 case MESA_FORMAT_RGBA_UNORM16:
269 return IMAGE_FORMAT_CLASS_4X16;
270
271 case MESA_FORMAT_R10G10B10A2_UNORM:
272 return IMAGE_FORMAT_CLASS_2_10_10_10;
273
274 case MESA_FORMAT_RGBA_UNORM8:
275 return IMAGE_FORMAT_CLASS_4X8;
276
277 case MESA_FORMAT_RG_UNORM16:
278 return IMAGE_FORMAT_CLASS_2X16;
279
280 case MESA_FORMAT_RG_UNORM8:
281 return IMAGE_FORMAT_CLASS_2X8;
282
283 case MESA_FORMAT_R_UNORM16:
284 return IMAGE_FORMAT_CLASS_1X16;
285
286 case MESA_FORMAT_R_UNORM8:
287 return IMAGE_FORMAT_CLASS_1X8;
288
289 case MESA_FORMAT_RGBA_SNORM16:
290 return IMAGE_FORMAT_CLASS_4X16;
291
292 case MESA_FORMAT_RGBA_SNORM8:
293 return IMAGE_FORMAT_CLASS_4X8;
294
295 case MESA_FORMAT_RG_SNORM16:
296 return IMAGE_FORMAT_CLASS_2X16;
297
298 case MESA_FORMAT_RG_SNORM8:
299 return IMAGE_FORMAT_CLASS_2X8;
300
301 case MESA_FORMAT_R_SNORM16:
302 return IMAGE_FORMAT_CLASS_1X16;
303
304 case MESA_FORMAT_R_SNORM8:
305 return IMAGE_FORMAT_CLASS_1X8;
306
307 default:
308 return IMAGE_FORMAT_CLASS_NONE;
309 }
310 }
311
312 static GLenum
_image_format_class_to_glenum(enum image_format_class class)313 _image_format_class_to_glenum(enum image_format_class class)
314 {
315 switch (class) {
316 case IMAGE_FORMAT_CLASS_NONE:
317 return GL_NONE;
318 case IMAGE_FORMAT_CLASS_1X8:
319 return GL_IMAGE_CLASS_1_X_8;
320 case IMAGE_FORMAT_CLASS_1X16:
321 return GL_IMAGE_CLASS_1_X_16;
322 case IMAGE_FORMAT_CLASS_1X32:
323 return GL_IMAGE_CLASS_1_X_32;
324 case IMAGE_FORMAT_CLASS_2X8:
325 return GL_IMAGE_CLASS_2_X_8;
326 case IMAGE_FORMAT_CLASS_2X16:
327 return GL_IMAGE_CLASS_2_X_16;
328 case IMAGE_FORMAT_CLASS_2X32:
329 return GL_IMAGE_CLASS_2_X_32;
330 case IMAGE_FORMAT_CLASS_10_11_11:
331 return GL_IMAGE_CLASS_11_11_10;
332 case IMAGE_FORMAT_CLASS_4X8:
333 return GL_IMAGE_CLASS_4_X_8;
334 case IMAGE_FORMAT_CLASS_4X16:
335 return GL_IMAGE_CLASS_4_X_16;
336 case IMAGE_FORMAT_CLASS_4X32:
337 return GL_IMAGE_CLASS_4_X_32;
338 case IMAGE_FORMAT_CLASS_2_10_10_10:
339 return GL_IMAGE_CLASS_10_10_10_2;
340 default:
341 assert(!"Invalid image_format_class");
342 return GL_NONE;
343 }
344 }
345
346 GLenum
_mesa_get_image_format_class(GLenum format)347 _mesa_get_image_format_class(GLenum format)
348 {
349 mesa_format tex_format = _mesa_get_shader_image_format(format);
350 if (tex_format == MESA_FORMAT_NONE)
351 return GL_NONE;
352
353 enum image_format_class class = get_image_format_class(tex_format);
354 return _image_format_class_to_glenum(class);
355 }
356
357 bool
_mesa_is_shader_image_format_supported(const struct gl_context * ctx,GLenum format)358 _mesa_is_shader_image_format_supported(const struct gl_context *ctx,
359 GLenum format)
360 {
361 switch (format) {
362 /* Formats supported on both desktop and ES GL, c.f. table 8.27 of the
363 * OpenGL ES 3.1 specification.
364 */
365 case GL_RGBA32F:
366 case GL_RGBA16F:
367 case GL_R32F:
368 case GL_RGBA32UI:
369 case GL_RGBA16UI:
370 case GL_RGBA8UI:
371 case GL_R32UI:
372 case GL_RGBA32I:
373 case GL_RGBA16I:
374 case GL_RGBA8I:
375 case GL_R32I:
376 case GL_RGBA8:
377 case GL_RGBA8_SNORM:
378 return true;
379
380 /* Formats supported on unextended desktop GL and the original
381 * ARB_shader_image_load_store extension, c.f. table 3.21 of the OpenGL 4.2
382 * specification or by GLES 3.1 with GL_NV_image_formats extension.
383 */
384 case GL_RG32F:
385 case GL_RG16F:
386 case GL_R11F_G11F_B10F:
387 case GL_R16F:
388 case GL_RGB10_A2UI:
389 case GL_RG32UI:
390 case GL_RG16UI:
391 case GL_RG8UI:
392 case GL_R16UI:
393 case GL_R8UI:
394 case GL_RG32I:
395 case GL_RG16I:
396 case GL_RG8I:
397 case GL_R16I:
398 case GL_R8I:
399 case GL_RGB10_A2:
400 case GL_RG8:
401 case GL_R8:
402 case GL_RG8_SNORM:
403 case GL_R8_SNORM:
404 return true;
405
406 /* Formats supported on unextended desktop GL and the original
407 * ARB_shader_image_load_store extension, c.f. table 3.21 of the OpenGL 4.2
408 * specification.
409 *
410 * Following formats are supported by GLES 3.1 with GL_NV_image_formats &
411 * GL_EXT_texture_norm16 extensions.
412 */
413 case GL_RGBA16:
414 case GL_RGBA16_SNORM:
415 case GL_RG16:
416 case GL_RG16_SNORM:
417 case GL_R16:
418 case GL_R16_SNORM:
419 return _mesa_is_desktop_gl(ctx) || _mesa_has_EXT_texture_norm16(ctx);
420
421 default:
422 return false;
423 }
424 }
425
426 struct gl_image_unit
_mesa_default_image_unit(struct gl_context * ctx)427 _mesa_default_image_unit(struct gl_context *ctx)
428 {
429 const GLenum format = _mesa_is_desktop_gl(ctx) ? GL_R8 : GL_R32UI;
430 const struct gl_image_unit u = {
431 .Access = GL_READ_ONLY,
432 .Format = format,
433 ._ActualFormat = _mesa_get_shader_image_format(format)
434 };
435 return u;
436 }
437
438 void
_mesa_init_image_units(struct gl_context * ctx)439 _mesa_init_image_units(struct gl_context *ctx)
440 {
441 unsigned i;
442
443 ASSERT_BITFIELD_SIZE(struct gl_image_unit, Format, MESA_FORMAT_COUNT);
444
445 for (i = 0; i < ARRAY_SIZE(ctx->ImageUnits); ++i)
446 ctx->ImageUnits[i] = _mesa_default_image_unit(ctx);
447 }
448
449
450 void
_mesa_free_image_textures(struct gl_context * ctx)451 _mesa_free_image_textures(struct gl_context *ctx)
452 {
453 unsigned i;
454
455 for (i = 0; i < ARRAY_SIZE(ctx->ImageUnits); ++i)
456 _mesa_reference_texobj(&ctx->ImageUnits[i].TexObj, NULL);
457 }
458
459 GLboolean
_mesa_is_image_unit_valid(struct gl_context * ctx,struct gl_image_unit * u)460 _mesa_is_image_unit_valid(struct gl_context *ctx, struct gl_image_unit *u)
461 {
462 struct gl_texture_object *t = u->TexObj;
463 mesa_format tex_format;
464
465 if (!t)
466 return GL_FALSE;
467
468 if (!t->_BaseComplete && !t->_MipmapComplete)
469 _mesa_test_texobj_completeness(ctx, t);
470
471 if (u->Level < t->BaseLevel ||
472 u->Level > t->_MaxLevel ||
473 (u->Level == t->BaseLevel && !t->_BaseComplete) ||
474 (u->Level != t->BaseLevel && !t->_MipmapComplete))
475 return GL_FALSE;
476
477 if (_mesa_tex_target_is_layered(t->Target) &&
478 u->_Layer >= _mesa_get_texture_layers(t, u->Level))
479 return GL_FALSE;
480
481 if (t->Target == GL_TEXTURE_BUFFER) {
482 tex_format = _mesa_get_shader_image_format(t->BufferObjectFormat);
483
484 } else {
485 struct gl_texture_image *img = (t->Target == GL_TEXTURE_CUBE_MAP ?
486 t->Image[u->_Layer][u->Level] :
487 t->Image[0][u->Level]);
488
489 if (!img || img->Border || img->NumSamples > ctx->Const.MaxImageSamples)
490 return GL_FALSE;
491
492 tex_format = _mesa_get_shader_image_format(img->InternalFormat);
493 }
494
495 if (!tex_format)
496 return GL_FALSE;
497
498 switch (t->ImageFormatCompatibilityType) {
499 case GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE:
500 if (_mesa_get_format_bytes(tex_format) !=
501 _mesa_get_format_bytes(u->_ActualFormat))
502 return GL_FALSE;
503 break;
504
505 case GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS:
506 if (get_image_format_class(tex_format) !=
507 get_image_format_class(u->_ActualFormat))
508 return GL_FALSE;
509 break;
510
511 default:
512 assert(!"Unexpected image format compatibility type");
513 }
514
515 return GL_TRUE;
516 }
517
518 static GLboolean
validate_bind_image_texture(struct gl_context * ctx,GLuint unit,GLuint texture,GLint level,GLint layer,GLenum access,GLenum format,bool check_level_layer)519 validate_bind_image_texture(struct gl_context *ctx, GLuint unit,
520 GLuint texture, GLint level, GLint layer,
521 GLenum access, GLenum format, bool check_level_layer)
522 {
523 assert(ctx->Const.MaxImageUnits <= MAX_IMAGE_UNITS);
524
525 if (unit >= ctx->Const.MaxImageUnits) {
526 _mesa_error(ctx, GL_INVALID_VALUE, "glBindImageTexture(unit)");
527 return GL_FALSE;
528 }
529
530 if (check_level_layer) {
531 /* EXT_shader_image_load_store doesn't throw an error if level or
532 * layer is negative.
533 */
534 if (level < 0) {
535 _mesa_error(ctx, GL_INVALID_VALUE, "glBindImageTexture(level)");
536 return GL_FALSE;
537 }
538
539 if (layer < 0) {
540 _mesa_error(ctx, GL_INVALID_VALUE, "glBindImageTexture(layer)");
541 return GL_FALSE;
542 }
543 }
544
545 if (access != GL_READ_ONLY &&
546 access != GL_WRITE_ONLY &&
547 access != GL_READ_WRITE) {
548 _mesa_error(ctx, GL_INVALID_VALUE, "glBindImageTexture(access)");
549 return GL_FALSE;
550 }
551
552 if (!_mesa_is_shader_image_format_supported(ctx, format)) {
553 _mesa_error(ctx, GL_INVALID_VALUE, "glBindImageTexture(format)");
554 return GL_FALSE;
555 }
556
557 return GL_TRUE;
558 }
559
560 static void
set_image_binding(struct gl_image_unit * u,struct gl_texture_object * texObj,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)561 set_image_binding(struct gl_image_unit *u, struct gl_texture_object *texObj,
562 GLint level, GLboolean layered, GLint layer, GLenum access,
563 GLenum format)
564 {
565 u->Level = level;
566 u->Access = access;
567 u->Format = format;
568 u->_ActualFormat = _mesa_get_shader_image_format(format);
569
570 if (texObj && _mesa_tex_target_is_layered(texObj->Target)) {
571 u->Layered = layered;
572 u->Layer = layer;
573 } else {
574 u->Layered = GL_FALSE;
575 u->Layer = 0;
576 }
577 u->_Layer = (u->Layered ? 0 : u->Layer);
578
579 _mesa_reference_texobj(&u->TexObj, texObj);
580 }
581
582 static void
bind_image_texture(struct gl_context * ctx,struct gl_texture_object * texObj,GLuint unit,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)583 bind_image_texture(struct gl_context *ctx, struct gl_texture_object *texObj,
584 GLuint unit, GLint level, GLboolean layered, GLint layer,
585 GLenum access, GLenum format)
586 {
587 struct gl_image_unit *u;
588
589 u = &ctx->ImageUnits[unit];
590
591 FLUSH_VERTICES(ctx, 0);
592 ctx->NewDriverState |= ctx->DriverFlags.NewImageUnits;
593
594 set_image_binding(u, texObj, level, layered, layer, access, format);
595 }
596
597 void GLAPIENTRY
_mesa_BindImageTexture_no_error(GLuint unit,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)598 _mesa_BindImageTexture_no_error(GLuint unit, GLuint texture, GLint level,
599 GLboolean layered, GLint layer, GLenum access,
600 GLenum format)
601 {
602 struct gl_texture_object *texObj = NULL;
603
604 GET_CURRENT_CONTEXT(ctx);
605
606 if (texture)
607 texObj = _mesa_lookup_texture(ctx, texture);
608
609 bind_image_texture(ctx, texObj, unit, level, layered, layer, access, format);
610 }
611
612 void GLAPIENTRY
_mesa_BindImageTexture(GLuint unit,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLenum format)613 _mesa_BindImageTexture(GLuint unit, GLuint texture, GLint level,
614 GLboolean layered, GLint layer, GLenum access,
615 GLenum format)
616 {
617 struct gl_texture_object *texObj = NULL;
618
619 GET_CURRENT_CONTEXT(ctx);
620
621 if (!validate_bind_image_texture(ctx, unit, texture, level, layer, access,
622 format, true))
623 return;
624
625 if (texture) {
626 texObj = _mesa_lookup_texture(ctx, texture);
627
628 if (!texObj) {
629 _mesa_error(ctx, GL_INVALID_VALUE, "glBindImageTexture(texture)");
630 return;
631 }
632
633 /* From section 8.22 "Texture Image Loads and Stores" of the OpenGL ES
634 * 3.1 spec:
635 *
636 * "An INVALID_OPERATION error is generated if texture is not the name
637 * of an immutable texture object."
638 *
639 * However note that issue 7 of the GL_OES_texture_buffer spec
640 * recognizes that there is no way to create immutable buffer textures,
641 * so those are excluded from this requirement.
642 *
643 * Additionally, issue 10 of the OES_EGL_image_external_essl3 spec
644 * states that glBindImageTexture must accept external textures.
645 */
646 if (_mesa_is_gles(ctx) && !texObj->Immutable &&
647 texObj->Target != GL_TEXTURE_BUFFER &&
648 texObj->Target != GL_TEXTURE_EXTERNAL_OES) {
649 _mesa_error(ctx, GL_INVALID_OPERATION,
650 "glBindImageTexture(!immutable)");
651 return;
652 }
653 }
654
655 bind_image_texture(ctx, texObj, unit, level, layered, layer, access, format);
656 }
657
658 void GLAPIENTRY
_mesa_BindImageTextureEXT(GLuint index,GLuint texture,GLint level,GLboolean layered,GLint layer,GLenum access,GLint format)659 _mesa_BindImageTextureEXT(GLuint index, GLuint texture, GLint level,
660 GLboolean layered, GLint layer, GLenum access,
661 GLint format)
662 {
663 struct gl_texture_object *texObj = NULL;
664
665 GET_CURRENT_CONTEXT(ctx);
666
667 if (!validate_bind_image_texture(ctx, index, texture, level, layer, access,
668 format, false))
669 return;
670
671 if (texture) {
672 texObj = _mesa_lookup_texture(ctx, texture);
673
674 if (!texObj) {
675 _mesa_error(ctx, GL_INVALID_VALUE, "glBindImageTextureEXT(texture)");
676 return;
677 }
678 }
679
680 bind_image_texture(ctx, texObj, index, level, layered, layer, access, format);
681 }
682
683 static ALWAYS_INLINE void
bind_image_textures(struct gl_context * ctx,GLuint first,GLuint count,const GLuint * textures,bool no_error)684 bind_image_textures(struct gl_context *ctx, GLuint first, GLuint count,
685 const GLuint *textures, bool no_error)
686 {
687 int i;
688
689 /* Assume that at least one binding will be changed */
690 FLUSH_VERTICES(ctx, 0);
691 ctx->NewDriverState |= ctx->DriverFlags.NewImageUnits;
692
693 /* Note that the error semantics for multi-bind commands differ from
694 * those of other GL commands.
695 *
696 * The Issues section in the ARB_multi_bind spec says:
697 *
698 * "(11) Typically, OpenGL specifies that if an error is generated by
699 * a command, that command has no effect. This is somewhat
700 * unfortunate for multi-bind commands, because it would require
701 * a first pass to scan the entire list of bound objects for
702 * errors and then a second pass to actually perform the
703 * bindings. Should we have different error semantics?
704 *
705 * RESOLVED: Yes. In this specification, when the parameters for
706 * one of the <count> binding points are invalid, that binding
707 * point is not updated and an error will be generated. However,
708 * other binding points in the same command will be updated if
709 * their parameters are valid and no other error occurs."
710 */
711
712 _mesa_HashLockMutex(ctx->Shared->TexObjects);
713
714 for (i = 0; i < count; i++) {
715 struct gl_image_unit *u = &ctx->ImageUnits[first + i];
716 const GLuint texture = textures ? textures[i] : 0;
717
718 if (texture) {
719 struct gl_texture_object *texObj = u->TexObj;
720 GLenum tex_format;
721
722 if (!texObj || texObj->Name != texture) {
723 texObj = _mesa_lookup_texture_locked(ctx, texture);
724 if (!no_error && !texObj) {
725 /* The ARB_multi_bind spec says:
726 *
727 * "An INVALID_OPERATION error is generated if any value
728 * in <textures> is not zero or the name of an existing
729 * texture object (per binding)."
730 */
731 _mesa_error(ctx, GL_INVALID_OPERATION,
732 "glBindImageTextures(textures[%d]=%u "
733 "is not zero or the name of an existing texture "
734 "object)", i, texture);
735 continue;
736 }
737 }
738
739 if (texObj->Target == GL_TEXTURE_BUFFER) {
740 tex_format = texObj->BufferObjectFormat;
741 } else {
742 struct gl_texture_image *image = texObj->Image[0][0];
743
744 if (!no_error && (!image || image->Width == 0 ||
745 image->Height == 0 || image->Depth == 0)) {
746 /* The ARB_multi_bind spec says:
747 *
748 * "An INVALID_OPERATION error is generated if the width,
749 * height, or depth of the level zero texture image of
750 * any texture in <textures> is zero (per binding)."
751 */
752 _mesa_error(ctx, GL_INVALID_OPERATION,
753 "glBindImageTextures(the width, height or depth "
754 "of the level zero texture image of "
755 "textures[%d]=%u is zero)", i, texture);
756 continue;
757 }
758
759 tex_format = image->InternalFormat;
760 }
761
762 if (!no_error &&
763 !_mesa_is_shader_image_format_supported(ctx, tex_format)) {
764 /* The ARB_multi_bind spec says:
765 *
766 * "An INVALID_OPERATION error is generated if the internal
767 * format of the level zero texture image of any texture
768 * in <textures> is not found in table 8.33 (per binding)."
769 */
770 _mesa_error(ctx, GL_INVALID_OPERATION,
771 "glBindImageTextures(the internal format %s of "
772 "the level zero texture image of textures[%d]=%u "
773 "is not supported)",
774 _mesa_enum_to_string(tex_format),
775 i, texture);
776 continue;
777 }
778
779 /* Update the texture binding */
780 set_image_binding(u, texObj, 0,
781 _mesa_tex_target_is_layered(texObj->Target),
782 0, GL_READ_WRITE, tex_format);
783 } else {
784 /* Unbind the texture from the unit */
785 set_image_binding(u, NULL, 0, GL_FALSE, 0, GL_READ_ONLY, GL_R8);
786 }
787 }
788
789 _mesa_HashUnlockMutex(ctx->Shared->TexObjects);
790 }
791
792 void GLAPIENTRY
_mesa_BindImageTextures_no_error(GLuint first,GLsizei count,const GLuint * textures)793 _mesa_BindImageTextures_no_error(GLuint first, GLsizei count,
794 const GLuint *textures)
795 {
796 GET_CURRENT_CONTEXT(ctx);
797
798 bind_image_textures(ctx, first, count, textures, true);
799 }
800
801 void GLAPIENTRY
_mesa_BindImageTextures(GLuint first,GLsizei count,const GLuint * textures)802 _mesa_BindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
803 {
804 GET_CURRENT_CONTEXT(ctx);
805
806 if (!ctx->Extensions.ARB_shader_image_load_store) {
807 _mesa_error(ctx, GL_INVALID_OPERATION, "glBindImageTextures()");
808 return;
809 }
810
811 if (first + count > ctx->Const.MaxImageUnits) {
812 /* The ARB_multi_bind spec says:
813 *
814 * "An INVALID_OPERATION error is generated if <first> + <count>
815 * is greater than the number of image units supported by
816 * the implementation."
817 */
818 _mesa_error(ctx, GL_INVALID_OPERATION,
819 "glBindImageTextures(first=%u + count=%d > the value of "
820 "GL_MAX_IMAGE_UNITS=%u)",
821 first, count, ctx->Const.MaxImageUnits);
822 return;
823 }
824
825 bind_image_textures(ctx, first, count, textures, false);
826 }
827