aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--X11/xtrans/Xtrans.c7
-rw-r--r--X11/xtrans/xtrans.pc.in2
-rw-r--r--fontconfig/configure.ac4
-rw-r--r--fontconfig/doc/Makefile.am1
-rw-r--r--fontconfig/doc/fcpattern.fncs27
-rw-r--r--fontconfig/doc/fcrange.fncs64
-rw-r--r--fontconfig/doc/fontconfig-devel.sgml7
-rw-r--r--fontconfig/fontconfig/fcprivate.h3
-rw-r--r--fontconfig/fontconfig/fontconfig.h28
-rw-r--r--fontconfig/src/Makefile.am1
-rw-r--r--fontconfig/src/fccfg.c48
-rw-r--r--fontconfig/src/fcdbg.c13
-rw-r--r--fontconfig/src/fcdefault.c47
-rw-r--r--fontconfig/src/fcfreetype.c35
-rw-r--r--fontconfig/src/fcint.h85
-rw-r--r--fontconfig/src/fclist.c2
-rw-r--r--fontconfig/src/fcmatch.c45
-rw-r--r--fontconfig/src/fcname.c49
-rw-r--r--fontconfig/src/fcobjs.h2
-rw-r--r--fontconfig/src/fcpat.c73
-rw-r--r--fontconfig/src/fcrange.c207
-rw-r--r--fontconfig/src/fcxml.c108
-rw-r--r--mesalib/SConstruct7
-rw-r--r--mesalib/configure.ac2
-rw-r--r--mesalib/docs/README.WIN3216
-rw-r--r--mesalib/docs/install.html4
-rw-r--r--mesalib/m4/ax_python_module.m449
-rw-r--r--mesalib/src/glsl/glsl_parser.yy1
-rw-r--r--mesalib/src/glsl/glsl_symbol_table.cpp25
-rw-r--r--mesalib/src/glsl/glsl_symbol_table.h2
-rw-r--r--mesalib/src/glsl/ir.h36
-rw-r--r--mesalib/src/glsl/ir_clone.cpp10
-rw-r--r--mesalib/src/glsl/ir_constant_expression.cpp205
-rw-r--r--mesalib/src/mapi/glapi/gen/glX_XML.py55
-rw-r--r--mesalib/src/mapi/glapi/gen/glX_doc.py280
-rw-r--r--mesalib/src/mapi/glapi/gen/glX_proto_common.py13
-rw-r--r--mesalib/src/mapi/glapi/gen/gl_XML.py217
-rw-r--r--mesalib/src/mesa/drivers/common/meta.c33
-rw-r--r--mesalib/src/mesa/drivers/common/meta.h2
-rw-r--r--mesalib/src/mesa/main/api_validate.c15
-rw-r--r--mesalib/src/mesa/main/context.c16
-rw-r--r--mesalib/src/mesa/main/fbobject.c94
-rw-r--r--mesalib/src/mesa/main/ff_fragment_shader.cpp8
-rw-r--r--mesalib/src/mesa/main/format_pack.c714
-rw-r--r--mesalib/src/mesa/main/format_unpack.c470
-rw-r--r--mesalib/src/mesa/main/formats.c20
-rw-r--r--mesalib/src/mesa/main/get.c21
-rw-r--r--mesalib/src/mesa/main/get_hash_params.py3
-rw-r--r--mesalib/src/mesa/main/mtypes.h27
-rw-r--r--mesalib/src/mesa/main/pipelineobj.c396
-rw-r--r--mesalib/src/mesa/main/pipelineobj.h3
-rw-r--r--mesalib/src/mesa/main/shaderapi.c144
-rw-r--r--mesalib/src/mesa/main/shaderapi.h3
-rw-r--r--mesalib/src/mesa/main/state.c14
-rw-r--r--mesalib/src/mesa/main/texstate.c6
-rw-r--r--mesalib/src/mesa/main/transformfeedback.c4
-rw-r--r--mesalib/src/mesa/main/uniform_query.cpp81
-rw-r--r--mesalib/src/mesa/main/uniforms.c66
-rw-r--r--mesalib/src/mesa/main/uniforms.h2
-rw-r--r--mesalib/src/mesa/main/varray.c7
-rw-r--r--mesalib/src/mesa/program/ir_to_mesa.cpp6
-rw-r--r--mesalib/src/mesa/state_tracker/st_atom_clip.c2
-rw-r--r--mesalib/src/mesa/state_tracker/st_atom_constbuf.c6
-rw-r--r--mesalib/src/mesa/state_tracker/st_atom_texture.c216
-rw-r--r--mesalib/src/mesa/state_tracker/st_cb_drawpixels.c2
-rw-r--r--mesalib/src/mesa/state_tracker/st_cb_queryobj.c18
-rw-r--r--mesalib/src/mesa/state_tracker/st_context.c17
-rw-r--r--mesalib/src/mesa/state_tracker/st_draw.c2
-rw-r--r--mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp2
-rw-r--r--mesalib/src/mesa/state_tracker/st_program.c2
-rw-r--r--mesalib/src/mesa/state_tracker/st_texture.c7
-rw-r--r--mesalib/src/mesa/state_tracker/st_texture.h4
-rw-r--r--mesalib/src/mesa/swrast/s_fragprog.c2
-rw-r--r--xorg-server/dix/gc.c8
-rw-r--r--xorg-server/fb/fbblt.c60
-rw-r--r--xorg-server/glamor/Makefile.am5
-rw-r--r--xorg-server/glamor/glamor.c32
-rw-r--r--xorg-server/glamor/glamor.h7
-rw-r--r--xorg-server/glamor/glamor_core.c45
-rw-r--r--xorg-server/glamor/glamor_fbo.c3
-rw-r--r--xorg-server/glamor/glamor_fill.c3
-rw-r--r--xorg-server/glamor/glamor_glyphs.c2
-rw-r--r--xorg-server/glamor/glamor_gradient.c60
-rw-r--r--xorg-server/glamor/glamor_largepixmap.c10
-rw-r--r--xorg-server/glamor/glamor_pixmap.c14
-rw-r--r--xorg-server/glamor/glamor_points.c129
-rw-r--r--xorg-server/glamor/glamor_polyops.c82
-rw-r--r--xorg-server/glamor/glamor_priv.h65
-rw-r--r--xorg-server/glamor/glamor_program.c394
-rw-r--r--xorg-server/glamor/glamor_program.h94
-rw-r--r--xorg-server/glamor/glamor_render.c29
-rw-r--r--xorg-server/glamor/glamor_segment.c39
-rw-r--r--xorg-server/glamor/glamor_transform.c215
-rw-r--r--xorg-server/glamor/glamor_transform.h87
-rw-r--r--xorg-server/glamor/glamor_trapezoid.c6
-rw-r--r--xorg-server/glamor/glamor_vbo.c6
-rw-r--r--xorg-server/hw/dmx/dmxinit.c4
-rw-r--r--xorg-server/hw/kdrive/ephyr/Makefile.am2
-rw-r--r--xorg-server/hw/kdrive/ephyr/ephyrinit.c5
-rw-r--r--xorg-server/hw/kdrive/ephyr/hostx.c10
-rw-r--r--xorg-server/hw/kdrive/src/kxv.c27
-rw-r--r--xorg-server/hw/kdrive/src/kxv.h36
-rw-r--r--xorg-server/hw/vfb/InitOutput.c5
-rw-r--r--xorg-server/hw/xfree86/Makefile.am2
-rw-r--r--xorg-server/hw/xfree86/common/xf86Extensions.c5
-rw-r--r--xorg-server/hw/xfree86/dixmods/glxmodule.c8
-rw-r--r--xorg-server/hw/xfree86/doc/ddxDesign.xml4
-rw-r--r--xorg-server/hw/xquartz/quartz.c5
-rw-r--r--xorg-server/hw/xwin/InitOutput.c5
-rw-r--r--xorg-server/include/extension.h3
-rw-r--r--xorg-server/include/opaque.h1
-rw-r--r--xorg-server/include/os.h6
-rw-r--r--xorg-server/include/xkbsrv.h3
-rw-r--r--xorg-server/mi/mibitblt.c2
-rw-r--r--xorg-server/mi/miinitext.c48
-rw-r--r--xorg-server/os/connection.c41
-rw-r--r--xorg-server/os/utils.c4
-rw-r--r--xorg-server/test/Makefile.am1
-rw-r--r--xorg-server/xkb/xkbUtils.c6
119 files changed, 3824 insertions, 2019 deletions
diff --git a/X11/xtrans/Xtrans.c b/X11/xtrans/Xtrans.c
index d9e32d01f..ae8ffad8e 100644
--- a/X11/xtrans/Xtrans.c
+++ b/X11/xtrans/Xtrans.c
@@ -48,8 +48,9 @@ from The Open Group.
*/
#include <ctype.h>
-#ifdef HAVE_SYSTEMD_DAEMON
+#include <stdlib.h>
#include <string.h>
+#ifdef HAVE_SYSTEMD_DAEMON
#include <systemd/sd-daemon.h>
#endif
@@ -166,8 +167,8 @@ TRANS(SelectTransport) (const char *protocol)
protobuf[PROTOBUFSIZE-1] = '\0';
for (i = 0; i < PROTOBUFSIZE && protobuf[i] != '\0'; i++)
- if (isupper (protobuf[i]))
- protobuf[i] = tolower (protobuf[i]);
+ if (isupper ((unsigned char)protobuf[i]))
+ protobuf[i] = tolower ((unsigned char)protobuf[i]);
/* Look at all of the configured protocols */
diff --git a/X11/xtrans/xtrans.pc.in b/X11/xtrans/xtrans.pc.in
index 90d19b16f..b8d135b3f 100644
--- a/X11/xtrans/xtrans.pc.in
+++ b/X11/xtrans/xtrans.pc.in
@@ -6,4 +6,4 @@ includedir=@includedir@
Name: XTrans
Description: Abstract network code for X
Version: @PACKAGE_VERSION@
-Cflags: -I${includedir} -D_BSD_SOURCE @fchown_define@ @sticky_bit_define@
+Cflags: -I${includedir} -D_DEFAULT_SOURCE -D_BSD_SOURCE @fchown_define@ @sticky_bit_define@
diff --git a/fontconfig/configure.ac b/fontconfig/configure.ac
index 1086a9a55..80875dfa2 100644
--- a/fontconfig/configure.ac
+++ b/fontconfig/configure.ac
@@ -321,6 +321,10 @@ AC_CHECK_MEMBER(FT_Bitmap_Size.y_ppem,
#include FT_FREETYPE_H])
AC_DEFINE_UNQUOTED(HAVE_FT_BITMAP_SIZE_Y_PPEM,$HAVE_FT_BITMAP_SIZE_Y_PPEM,
[FT_Bitmap_Size structure includes y_ppem field])
+AC_CHECK_MEMBERS([TT_OS2.usLowerOpticalPointSize, TT_OS2.usUpperOpticalPointSize], [], [], [[
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TRUETYPE_TABLES_H]])
CFLAGS="$fontconfig_save_cflags"
LIBS="$fontconfig_save_libs"
diff --git a/fontconfig/doc/Makefile.am b/fontconfig/doc/Makefile.am
index 78a7cdbf1..7503219b8 100644
--- a/fontconfig/doc/Makefile.am
+++ b/fontconfig/doc/Makefile.am
@@ -81,6 +81,7 @@ DOC_FUNCS_FNCS = \
fcobjectset.fncs \
fcobjecttype.fncs \
fcpattern.fncs \
+ fcrange.fncs \
fcstring.fncs \
fcstrset.fncs \
fcvalue.fncs \
diff --git a/fontconfig/doc/fcpattern.fncs b/fontconfig/doc/fcpattern.fncs
index 1df1c4f61..1049d77af 100644
--- a/fontconfig/doc/fcpattern.fncs
+++ b/fontconfig/doc/fcpattern.fncs
@@ -181,12 +181,21 @@ values added to the list have binding <parameter>weak</parameter> instead of <pa
@TYPE2+++++++@ const char * @ARG2+++++++@ object
@TYPE3+++++++@ const FcLangSet * @ARG3+++++++@ l
+@PROTOTYPE++++++++@
+@RET++++++++@ FcBool
+@FUNC++++++++@ FcPatternAddRange
+@TYPE1++++++++@ FcPattern * @ARG1++++++++@ p
+@TYPE2++++++++@ const char * @ARG2++++++++@ object
+@TYPE3++++++++@ const FcRange * @ARG3++++++++@ r
+
@PURPOSE@ Add a typed value to a pattern
@DESC@
These are all convenience functions that insert objects of the specified
type into the pattern. Use these in preference to FcPatternAdd as they
will provide compile-time typechecking. These all append values to
any existing list of values.
+
+<function>FcPatternAddRange</function> are available since 2.11.91.
@@
@RET@ FcResult
@@ -257,16 +266,24 @@ within the pattern directly. Applications must not free this value.
@FUNC++++++@ FcPatternGetFTFace
@TYPE1++++++@ FcPattern * @ARG1++++++@ p
@TYPE2++++++@ const char * @ARG2++++++@ object
-@TYPE3+++++@ int% @ARG3+++++@ n
-@TYPE3++++++@ FT_Face * @ARG3++++++@ f
+@TYPE3++++++@ int% @ARG3++++++@ n
+@TYPE4++++++@ FT_Face * @ARG4++++++@ f
@PROTOTYPE+++++++@
@RET+++++++@ FcResult
@FUNC+++++++@ FcPatternGetLangSet
@TYPE1+++++++@ FcPattern * @ARG1+++++++@ p
@TYPE2+++++++@ const char * @ARG2+++++++@ object
-@TYPE3+++++@ int% @ARG3+++++@ n
-@TYPE3+++++++@ FcLangSet ** @ARG3+++++++@ l
+@TYPE3+++++++@ int% @ARG3+++++++@ n
+@TYPE4+++++++@ FcLangSet ** @ARG4+++++++@ l
+
+@PROTOTYPE++++++++@
+@RET++++++++@ FcResult
+@FUNC++++++++@ FcPatternGetRange
+@TYPE1++++++++@ FcPattern * @ARG1++++++++@ p
+@TYPE2++++++++@ const char * @ARG2++++++++@ object
+@TYPE3++++++++@ int% @ARG3++++++++@ n
+@TYPE4++++++++@ FcRange ** @ARG4++++++++@ r
@PURPOSE@ Return a typed value from a pattern
@DESC@
@@ -275,6 +292,8 @@ returned data is of the expected type. They return FcResultTypeMismatch if
this is not the case. Note that these (like FcPatternGet) do not make a
copy of any data structure referenced by the return value. Use these
in preference to FcPatternGet to provide compile-time typechecking.
+
+<function>FcPatternGetRange</function> are available since 2.11.91.
@@
@RET@ FcPattern *
diff --git a/fontconfig/doc/fcrange.fncs b/fontconfig/doc/fcrange.fncs
new file mode 100644
index 000000000..605459525
--- /dev/null
+++ b/fontconfig/doc/fcrange.fncs
@@ -0,0 +1,64 @@
+/*
+ * fontconfig/doc/fcrange.fncs
+ *
+ * Copyright © 2003 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the author(s) not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. The authors make no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+@RET@ FcRange *
+@FUNC@ FcRangeCopy
+@TYPE1@ const FcRange * @ARG1@ range
+@PURPOSE@ Copy a range object
+@DESC@
+<function>FcRangeCopy</function> creates a new FcRange object and
+populates it with the contents of <parameter>range</parameter>.
+@SINCE@ 2.11.91
+@@
+
+@RET@ FcRange *
+@FUNC@ FcRangeCreateDouble
+@TYPE1@ double @ARG1@ begin
+@TYPE2@ double @ARG2@ end
+@PURPOSE@ create a range object for double
+@DESC@
+<function>FcRangeCreateDouble</function> creates a new FcRange object with
+double sized value.
+@SINCE@ 2.11.91
+@@
+
+@RET@ FcRange *
+@FUNC@ FcRangeCreateInteger
+@TYPE1@ int @ARG1@ begin
+@TYPE2@ int @ARG2@ end
+@PURPOSE@ create a range object for integer
+@DESC@
+<function>FcRangeCreateInteger</function> creates a new FcRange object with
+integer sized value.
+@SINCE@ 2.11.91
+@@
+
+@RET@ void
+@FUNC@ FcRangeDestroy
+@TYPE1@ FcRange * @ARG1@ range
+@PURPOSE@ destroy a range object
+@DESC@
+<function>FcRangeDestroy</function> destroys a FcRange object, freeing
+all memory associated with it.
+@SINCE@ 2.11.91
+@@
diff --git a/fontconfig/doc/fontconfig-devel.sgml b/fontconfig/doc/fontconfig-devel.sgml
index 7306d7924..e2cb1c281 100644
--- a/fontconfig/doc/fontconfig-devel.sgml
+++ b/fontconfig/doc/fontconfig-devel.sgml
@@ -16,6 +16,7 @@
<!ENTITY fcobjectset SYSTEM "fcobjectset.sgml">
<!ENTITY fcobjecttype SYSTEM "fcobjecttype.sgml">
<!ENTITY fcpattern SYSTEM "fcpattern.sgml">
+<!ENTITY fcrange SYSTEM "fcrange.sgml">
<!ENTITY fcstring SYSTEM "fcstring.sgml">
<!ENTITY fcstrset SYSTEM "fcstrset.sgml">
<!ENTITY fcvalue SYSTEM "fcvalue.sgml">
@@ -508,6 +509,12 @@ FcMatrix structures hold an affine transformation in matrix form.
</para>
&fcmatrix;
</sect2>
+ <sect2><title>FcRange</title>
+ <para>
+An FcRange holds two variables to indicate a range in between.
+ </para>
+ &fcrange;
+ </sect2>
<sect2><title>FcConfig</title>
<para>
An FcConfig object holds the internal representation of a configuration.
diff --git a/fontconfig/fontconfig/fcprivate.h b/fontconfig/fontconfig/fcprivate.h
index 210c1d8a3..a6ee5c234 100644
--- a/fontconfig/fontconfig/fcprivate.h
+++ b/fontconfig/fontconfig/fcprivate.h
@@ -77,6 +77,9 @@
case FcTypeLangSet: \
__v__.u.l = va_arg (va, const FcLangSet *); \
break; \
+ case FcTypeRange: \
+ __v__.u.r = va_arg (va, const FcRange *); \
+ break; \
} \
if (!FcPatternAdd (__p__, __o__, __v__, FcTrue)) \
goto _FcPatternVapBuild_bail1; \
diff --git a/fontconfig/fontconfig/fontconfig.h b/fontconfig/fontconfig/fontconfig.h
index 225825127..069cb60dd 100644
--- a/fontconfig/fontconfig/fontconfig.h
+++ b/fontconfig/fontconfig/fontconfig.h
@@ -75,7 +75,7 @@ typedef int FcBool;
#define FC_STYLE "style" /* String */
#define FC_SLANT "slant" /* Int */
#define FC_WEIGHT "weight" /* Int */
-#define FC_SIZE "size" /* Double */
+#define FC_SIZE "size" /* Range (double) */
#define FC_ASPECT "aspect" /* Double */
#define FC_PIXEL_SIZE "pixelsize" /* Double */
#define FC_SPACING "spacing" /* Int */
@@ -194,7 +194,8 @@ typedef enum _FcType {
FcTypeMatrix,
FcTypeCharSet,
FcTypeFTFace,
- FcTypeLangSet
+ FcTypeLangSet,
+ FcTypeRange
} FcType;
typedef struct _FcMatrix {
@@ -231,6 +232,8 @@ typedef struct _FcPattern FcPattern;
typedef struct _FcLangSet FcLangSet;
+typedef struct _FcRange FcRange;
+
typedef struct _FcValue {
FcType type;
union {
@@ -242,6 +245,7 @@ typedef struct _FcValue {
const FcCharSet *c;
void *f;
const FcLangSet *l;
+ const FcRange *r;
} u;
} FcValue;
@@ -853,6 +857,9 @@ FcPatternAddBool (FcPattern *p, const char *object, FcBool b);
FcPublic FcBool
FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls);
+FcPublic FcBool
+FcPatternAddRange (FcPattern *p, const char *object, const FcRange *r);
+
FcPublic FcResult
FcPatternGetInteger (const FcPattern *p, const char *object, int n, int *i);
@@ -874,6 +881,9 @@ FcPatternGetBool (const FcPattern *p, const char *object, int n, FcBool *b);
FcPublic FcResult
FcPatternGetLangSet (const FcPattern *p, const char *object, int n, FcLangSet **ls);
+FcPublic FcResult
+FcPatternGetRange (const FcPattern *p, const char *object, int id, FcRange **r);
+
FcPublic FcPattern *
FcPatternVaBuild (FcPattern *p, va_list va);
@@ -883,6 +893,20 @@ FcPatternBuild (FcPattern *p, ...) FC_ATTRIBUTE_SENTINEL(0);
FcPublic FcChar8 *
FcPatternFormat (FcPattern *pat, const FcChar8 *format);
+/* fcrange.c */
+FcPublic FcRange *
+FcRangeCreateDouble (double begin, double end);
+
+FcPublic FcRange *
+FcRangeCreateInteger (FcChar32 begin, FcChar32 end);
+
+FcPublic void
+FcRangeDestroy (FcRange *range);
+
+FcPublic FcRange *
+FcRangeCopy (const FcRange *r);
+
+
/* fcstr.c */
FcPublic FcChar8 *
diff --git a/fontconfig/src/Makefile.am b/fontconfig/src/Makefile.am
index 066cc03e7..be20eba05 100644
--- a/fontconfig/src/Makefile.am
+++ b/fontconfig/src/Makefile.am
@@ -151,6 +151,7 @@ libfontconfig_la_SOURCES = \
fcobjs.h \
fcobjshash.h \
fcpat.c \
+ fcrange.c \
fcserialize.c \
fcstat.c \
fcstr.c \
diff --git a/fontconfig/src/fccfg.c b/fontconfig/src/fccfg.c
index 6377fd7c6..cdb8c0f25 100644
--- a/fontconfig/src/fccfg.c
+++ b/fontconfig/src/fccfg.c
@@ -722,6 +722,11 @@ FcConfigPromote (FcValue v, FcValue u, FcValuePromotionBuffer *buf)
v.u.l = FcLangSetPromote (v.u.s, buf);
v.type = FcTypeLangSet;
}
+ if (buf && v.type == FcTypeDouble && u.type == FcTypeRange)
+ {
+ v.u.r = FcRangePromote (v.u.d, buf);
+ v.type = FcTypeRange;
+ }
return v;
}
@@ -894,6 +899,9 @@ FcConfigCompareValue (const FcValue *left_o,
break;
}
break;
+ case FcTypeRange:
+ ret = FcRangeCompare (op, left.u.r, right.u.r);
+ break;
}
}
else
@@ -915,10 +923,11 @@ FcConfigCompareValue (const FcValue *left_o,
static FcValue
FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
{
- FcValue v, vl, vr;
+ FcValue v, vl, vr, vle, vre;
FcMatrix *m;
FcChar8 *str;
FcOp op = FC_OP_GET_OP (e->op);
+ FcValuePromotionBuffer buf1, buf2;
switch ((int) op) {
case FcOpInteger:
@@ -967,6 +976,11 @@ FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
v.u.l = e->u.lval;
v = FcValueSave (v);
break;
+ case FcOpRange:
+ v.type = FcTypeRange;
+ v.u.r = e->u.rval;
+ v = FcValueSave (v);
+ break;
case FcOpBool:
v.type = FcTypeBool;
v.u.b = e->u.bval;
@@ -1033,28 +1047,28 @@ FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
case FcOpDivide:
vl = FcConfigEvaluate (p, p_pat, kind, e->u.tree.left);
vr = FcConfigEvaluate (p, p_pat, kind, e->u.tree.right);
- vl = FcConfigPromote (vl, vr, NULL);
- vr = FcConfigPromote (vr, vl, NULL);
- if (vl.type == vr.type)
+ vle = FcConfigPromote (vl, vr, &buf1);
+ vre = FcConfigPromote (vr, vle, &buf2);
+ if (vle.type == vre.type)
{
- switch ((int) vl.type) {
+ switch ((int) vle.type) {
case FcTypeDouble:
switch ((int) op) {
case FcOpPlus:
v.type = FcTypeDouble;
- v.u.d = vl.u.d + vr.u.d;
+ v.u.d = vle.u.d + vre.u.d;
break;
case FcOpMinus:
v.type = FcTypeDouble;
- v.u.d = vl.u.d - vr.u.d;
+ v.u.d = vle.u.d - vre.u.d;
break;
case FcOpTimes:
v.type = FcTypeDouble;
- v.u.d = vl.u.d * vr.u.d;
+ v.u.d = vle.u.d * vre.u.d;
break;
case FcOpDivide:
v.type = FcTypeDouble;
- v.u.d = vl.u.d / vr.u.d;
+ v.u.d = vle.u.d / vre.u.d;
break;
default:
v.type = FcTypeVoid;
@@ -1071,11 +1085,11 @@ FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
switch ((int) op) {
case FcOpOr:
v.type = FcTypeBool;
- v.u.b = vl.u.b || vr.u.b;
+ v.u.b = vle.u.b || vre.u.b;
break;
case FcOpAnd:
v.type = FcTypeBool;
- v.u.b = vl.u.b && vr.u.b;
+ v.u.b = vle.u.b && vre.u.b;
break;
default:
v.type = FcTypeVoid;
@@ -1086,7 +1100,7 @@ FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
switch ((int) op) {
case FcOpPlus:
v.type = FcTypeString;
- str = FcStrPlus (vl.u.s, vr.u.s);
+ str = FcStrPlus (vle.u.s, vre.u.s);
v.u.s = FcStrdup (str);
FcStrFree (str);
@@ -1105,7 +1119,7 @@ FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
m = malloc (sizeof (FcMatrix));
if (m)
{
- FcMatrixMultiply (m, vl.u.m, vr.u.m);
+ FcMatrixMultiply (m, vle.u.m, vre.u.m);
v.u.m = m;
}
else
@@ -1122,13 +1136,13 @@ FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
switch ((int) op) {
case FcOpPlus:
v.type = FcTypeCharSet;
- v.u.c = FcCharSetUnion (vl.u.c, vr.u.c);
+ v.u.c = FcCharSetUnion (vle.u.c, vre.u.c);
if (!v.u.c)
v.type = FcTypeVoid;
break;
case FcOpMinus:
v.type = FcTypeCharSet;
- v.u.c = FcCharSetSubtract (vl.u.c, vr.u.c);
+ v.u.c = FcCharSetSubtract (vle.u.c, vre.u.c);
if (!v.u.c)
v.type = FcTypeVoid;
break;
@@ -1141,13 +1155,13 @@ FcConfigEvaluate (FcPattern *p, FcPattern *p_pat, FcMatchKind kind, FcExpr *e)
switch ((int) op) {
case FcOpPlus:
v.type = FcTypeLangSet;
- v.u.l = FcLangSetUnion (vl.u.l, vr.u.l);
+ v.u.l = FcLangSetUnion (vle.u.l, vre.u.l);
if (!v.u.l)
v.type = FcTypeVoid;
break;
case FcOpMinus:
v.type = FcTypeLangSet;
- v.u.l = FcLangSetSubtract (vl.u.l, vr.u.l);
+ v.u.l = FcLangSetSubtract (vle.u.l, vre.u.l);
if (!v.u.l)
v.type = FcTypeVoid;
break;
diff --git a/fontconfig/src/fcdbg.c b/fontconfig/src/fcdbg.c
index d74bc2769..ef038f017 100644
--- a/fontconfig/src/fcdbg.c
+++ b/fontconfig/src/fcdbg.c
@@ -29,6 +29,8 @@
static void
_FcValuePrintFile (FILE *f, const FcValue v)
{
+ FcRange r;
+
switch (v.type) {
case FcTypeUnknown:
fprintf (f, "<unknown>");
@@ -61,6 +63,10 @@ _FcValuePrintFile (FILE *f, const FcValue v)
case FcTypeFTFace:
fprintf (f, "face");
break;
+ case FcTypeRange:
+ r = FcRangeCanonicalize (v.u.r);
+ fprintf (f, "(%g, %g)", r.u.d.begin, r.u.d.end);
+ break;
}
}
@@ -261,6 +267,8 @@ FcOpPrint (FcOp op_)
void
FcExprPrint (const FcExpr *expr)
{
+ FcRange r;
+
if (!expr) printf ("none");
else switch (FC_OP_GET_OP (expr->op)) {
case FcOpInteger: printf ("%d", expr->u.ival); break;
@@ -277,7 +285,10 @@ FcExprPrint (const FcExpr *expr)
FcExprPrint (expr->u.mexpr->yy);
printf ("]");
break;
- case FcOpRange: break;
+ case FcOpRange:
+ r = FcRangeCanonicalize (expr->u.rval);
+ printf ("(%g, %g)", r.u.d.begin, r.u.d.end);
+ break;
case FcOpBool: printf ("%s", expr->u.bval ? "true" : "false"); break;
case FcOpCharSet: printf ("charset\n"); break;
case FcOpLangSet:
diff --git a/fontconfig/src/fcdefault.c b/fontconfig/src/fcdefault.c
index 4beda7c00..7c16f4841 100644
--- a/fontconfig/src/fcdefault.c
+++ b/fontconfig/src/fcdefault.c
@@ -219,6 +219,7 @@ FcDefaultSubstitute (FcPattern *pattern)
{
FcValue v, namelang, v2;
int i;
+ double dpi, size, scale, pixelsize;
if (FcPatternObjectGet (pattern, FC_WEIGHT_OBJECT, 0, &v) == FcResultNoMatch )
FcPatternObjectAddInteger (pattern, FC_WEIGHT_OBJECT, FC_WEIGHT_NORMAL);
@@ -233,32 +234,30 @@ FcDefaultSubstitute (FcPattern *pattern)
if (FcPatternObjectGet (pattern, FcBoolDefaults[i].field, 0, &v) == FcResultNoMatch)
FcPatternObjectAddBool (pattern, FcBoolDefaults[i].field, FcBoolDefaults[i].value);
- if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) == FcResultNoMatch)
- {
- double dpi, size, scale;
+ if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
+ size = 12.0L;
+ if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
+ scale = 1.0;
+ if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
+ dpi = 75.0;
- if (FcPatternObjectGetDouble (pattern, FC_SIZE_OBJECT, 0, &size) != FcResultMatch)
- {
- size = 12.0;
- (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
- FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);
- }
- if (FcPatternObjectGetDouble (pattern, FC_SCALE_OBJECT, 0, &scale) != FcResultMatch)
- {
- scale = 1.0;
- (void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
- FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
- }
- size *= scale;
- if (FcPatternObjectGetDouble (pattern, FC_DPI_OBJECT, 0, &dpi) != FcResultMatch)
- {
- dpi = 75.0;
- (void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
- FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
- }
- size *= dpi / 72.0;
- FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, size);
+ if (FcPatternObjectGet (pattern, FC_PIXEL_SIZE_OBJECT, 0, &v) != FcResultMatch)
+ {
+ (void) FcPatternObjectDel (pattern, FC_SCALE_OBJECT);
+ FcPatternObjectAddDouble (pattern, FC_SCALE_OBJECT, scale);
+ pixelsize = size * scale;
+ (void) FcPatternObjectDel (pattern, FC_DPI_OBJECT);
+ FcPatternObjectAddDouble (pattern, FC_DPI_OBJECT, dpi);
+ pixelsize *= dpi / 72.0;
+ FcPatternObjectAddDouble (pattern, FC_PIXEL_SIZE_OBJECT, pixelsize);
+ }
+ else
+ {
+ size = v.u.d;
+ size = size / dpi * 72.0 / scale;
}
+ (void) FcPatternObjectDel (pattern, FC_SIZE_OBJECT);
+ FcPatternObjectAddDouble (pattern, FC_SIZE_OBJECT, size);
if (FcPatternObjectGet (pattern, FC_FONTVERSION_OBJECT, 0, &v) == FcResultNoMatch)
{
diff --git a/fontconfig/src/fcfreetype.c b/fontconfig/src/fcfreetype.c
index d271d69e2..d0932b31b 100644
--- a/fontconfig/src/fcfreetype.c
+++ b/fontconfig/src/fcfreetype.c
@@ -1107,6 +1107,8 @@ FcFreeTypeQueryFace (const FT_Face face,
FcChar8 *hashstr = NULL;
FT_Error err;
FT_ULong len = 0, alen;
+ FcRange *r = NULL;
+ double lower_size = 0.0L, upper_size = DBL_MAX;
pat = FcPatternCreate ();
if (!pat)
@@ -1514,6 +1516,39 @@ FcFreeTypeQueryFace (const FT_Face face,
free (complex_);
}
+#if defined (HAVE_TT_OS2_USUPPEROPTICALPOINTSIZE) && defined (HAVE_TT_OS2_USLOWEROPTICALPOINTSIZE)
+ if (os2 && os2->version >= 0x0005 && os2->version != 0xffff)
+ {
+ /* usLowerPointSize and usUpperPointSize is actually twips */
+ lower_size = os2->usLowerOpticalPointSize / 20.0L;
+ upper_size = os2->usUpperOpticalPointSize / 20.0L;
+ }
+#endif
+ if (os2)
+ {
+ r = FcRangeCreateDouble (lower_size, upper_size);
+ if (!FcPatternAddRange (pat, FC_SIZE, r))
+ {
+ FcRangeDestroy (r);
+ goto bail1;
+ }
+ FcRangeDestroy (r);
+ }
+ else
+ {
+ for (i = 0; i < face->num_fixed_sizes; i++)
+ {
+ double d = FcGetPixelSize (face, i);
+ r = FcRangeCreateDouble (d, d);
+ if (!FcPatternAddRange (pat, FC_SIZE, r))
+ {
+ FcRangeDestroy (r);
+ goto bail1;
+ }
+ FcRangeDestroy (r);
+ }
+ }
+
/*
* Type 1: Check for FontInfo dictionary information
* Code from g2@magestudios.net (Gerard Escalante)
diff --git a/fontconfig/src/fcint.h b/fontconfig/src/fcint.h
index cdf2daba0..dd26fd89a 100644
--- a/fontconfig/src/fcint.h
+++ b/fontconfig/src/fcint.h
@@ -38,6 +38,8 @@
#include <assert.h>
#include <errno.h>
#include <limits.h>
+#include <float.h>
+#include <math.h>
#include <unistd.h>
#include <stddef.h>
#include <sys/types.h>
@@ -94,6 +96,11 @@ extern pfnSHGetFolderPathA pSHGetFolderPathA;
#define FC_MAX(a,b) ((a) > (b) ? (a) : (b))
#define FC_ABS(a) ((a) < 0 ? -(a) : (a))
+#define FcDoubleIsZero(a) (fabs ((a)) <= DBL_EPSILON)
+#define FcDoubleCmpEQ(a,b) (fabs ((a) - (b)) <= DBL_EPSILON)
+#define FcDoubleCmpGE(a,b) (FcDoubleCmpEQ (a, b) || (a) > (b))
+#define FcDoubleCmpLE(a,b) (FcDoubleCmpEQ (a, b) || (a) < (b))
+
/* slim_internal.h */
#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__) && !defined(__sun)
#define FcPrivate __attribute__((__visibility__("hidden")))
@@ -161,6 +168,7 @@ typedef enum _FcValueBinding {
#define FcValueString(v) FcPointerMember(v,u.s,FcChar8)
#define FcValueCharSet(v) FcPointerMember(v,u.c,const FcCharSet)
#define FcValueLangSet(v) FcPointerMember(v,u.l,const FcLangSet)
+#define FcValueRange(v) FcPointerMember(v,u.r,const FcRange)
typedef struct _FcValueList *FcValueListPtr;
@@ -244,20 +252,38 @@ typedef struct _FcExprName {
FcMatchKind kind;
} FcExprName;
+typedef struct _FcRangeInt {
+ FcChar32 begin;
+ FcChar32 end;
+} FcRangeInt;
+typedef struct _FcRangeDouble {
+ double begin;
+ double end;
+} FcRangeDouble;
+struct _FcRange {
+ FcBool is_double;
+ FcBool is_inclusive;
+ union {
+ FcRangeInt i;
+ FcRangeDouble d;
+ } u;
+};
+
typedef struct _FcExpr {
FcOp op;
union {
- int ival;
- double dval;
- const FcChar8 *sval;
- FcExprMatrix *mexpr;
- FcBool bval;
- FcCharSet *cval;
- FcLangSet *lval;
-
- FcExprName name;
- const FcChar8 *constant;
+ int ival;
+ double dval;
+ const FcChar8 *sval;
+ FcExprMatrix *mexpr;
+ FcBool bval;
+ FcCharSet *cval;
+ FcLangSet *lval;
+ FcRange *rval;
+
+ FcExprName name;
+ const FcChar8 *constant;
struct {
struct _FcExpr *left, *right;
} tree;
@@ -532,13 +558,6 @@ typedef struct _FcFileTime {
typedef struct _FcCharMap FcCharMap;
-typedef struct _FcRange FcRange;
-
-struct _FcRange {
- FcChar32 begin;
- FcChar32 end;
-};
-
typedef struct _FcStatFS FcStatFS;
struct _FcStatFS {
@@ -1008,6 +1027,9 @@ FcPatternObjectAddBool (FcPattern *p, FcObject object, FcBool b);
FcPrivate FcBool
FcPatternObjectAddLangSet (FcPattern *p, FcObject object, const FcLangSet *ls);
+FcPrivate FcBool
+FcPatternObjectAddRange (FcPattern *p, FcObject object, const FcRange *r);
+
FcPrivate FcResult
FcPatternObjectGetInteger (const FcPattern *p, FcObject object, int n, int *i);
@@ -1029,6 +1051,9 @@ FcPatternObjectGetBool (const FcPattern *p, FcObject object, int n, FcBool *b);
FcPrivate FcResult
FcPatternObjectGetLangSet (const FcPattern *p, FcObject object, int n, FcLangSet **ls);
+FcPrivate FcResult
+FcPatternObjectGetRange (const FcPattern *p, FcObject object, int id, FcRange **r);
+
FcPrivate FcBool
FcPatternAppend (FcPattern *p, FcPattern *s);
@@ -1056,6 +1081,32 @@ extern FcPrivate const FcMatrix FcIdentityMatrix;
FcPrivate void
FcMatrixFree (FcMatrix *mat);
+/* fcrange.c */
+
+FcPrivate FcRange
+FcRangeCanonicalize (const FcRange *range);
+
+FcPrivate FcRange *
+FcRangePromote (double v, FcValuePromotionBuffer *vbuf);
+
+FcPrivate FcBool
+FcRangeIsZero (const FcRange *r);
+
+FcPrivate FcBool
+FcRangeIsInRange (const FcRange *a, const FcRange *b);
+
+FcPrivate FcBool
+FcRangeCompare (FcOp op, const FcRange *a, const FcRange *b);
+
+FcPrivate FcChar32
+FcRangeHash (const FcRange *r);
+
+FcPrivate FcBool
+FcRangeSerializeAlloc (FcSerialize *serialize, const FcRange *r);
+
+FcPrivate FcRange *
+FcRangeSerialize (FcSerialize *serialize, const FcRange *r);
+
/* fcstat.c */
FcPrivate int
diff --git a/fontconfig/src/fclist.c b/fontconfig/src/fclist.c
index a365098a4..6ad297ca4 100644
--- a/fontconfig/src/fclist.c
+++ b/fontconfig/src/fclist.c
@@ -273,6 +273,8 @@ FcListValueHash (FcValue *value)
return (long) v.u.f;
case FcTypeLangSet:
return FcLangSetHash (v.u.l);
+ case FcTypeRange:
+ return FcRangeHash (v.u.r);
}
return 0;
}
diff --git a/fontconfig/src/fcmatch.c b/fontconfig/src/fcmatch.c
index 93e013f9b..0c0a0670e 100644
--- a/fontconfig/src/fcmatch.c
+++ b/fontconfig/src/fcmatch.c
@@ -189,6 +189,49 @@ FcCompareSize (FcValue *value1, FcValue *value2)
}
static double
+FcCompareSizeRange (FcValue *v1, FcValue *v2)
+{
+ FcValue value1 = FcValueCanonicalize (v1);
+ FcValue value2 = FcValueCanonicalize (v2);
+ FcRange *r1 = NULL, *r2 = NULL;
+ double ret = -1.0;
+
+ switch ((int) value1.type) {
+ case FcTypeDouble:
+ r1 = FcRangeCreateDouble (value1.u.d, value1.u.d);
+ break;
+ case FcTypeRange:
+ r1 = FcRangeCopy (value1.u.r);
+ break;
+ default:
+ goto bail;
+ }
+ switch ((int) value2.type) {
+ case FcTypeDouble:
+ r2 = FcRangeCreateDouble (value2.u.d, value2.u.d);
+ break;
+ case FcTypeRange:
+ r2 = FcRangeCopy (value2.u.r);
+ break;
+ default:
+ goto bail;
+ }
+
+ if (FcRangeIsInRange (r1, r2))
+ ret = 0.0;
+ else
+ ret = FC_MIN (fabs (r1->u.d.end - r2->u.d.begin), fabs (r1->u.d.begin - r2->u.d.end));
+
+bail:
+ if (r1)
+ FcRangeDestroy (r1);
+ if (r2)
+ FcRangeDestroy (r2);
+
+ return ret;
+}
+
+static double
FcCompareFilename (FcValue *v1, FcValue *v2)
{
const FcChar8 *s1 = FcValueString (v1), *s2 = FcValueString (v2);
@@ -227,6 +270,7 @@ FcCompareHash (FcValue *v1, FcValue *v2)
#define PRI_FcCompareLang(n) PRI1(n)
#define PRI_FcComparePostScript(n) PRI1(n)
#define PRI_FcCompareHash(n) PRI1(n)
+#define PRI_FcCompareSizeRange(n) PRI1(n)
#define FC_OBJECT(NAME, Type, Cmp) PRI_##Cmp(NAME)
@@ -255,6 +299,7 @@ typedef enum _FcMatcherPriority {
PRI_FAMILY_WEAK,
PRI_POSTSCRIPT_NAME_WEAK,
PRI1(SPACING),
+ PRI1(SIZE),
PRI1(PIXEL_SIZE),
PRI1(STYLE),
PRI1(SLANT),
diff --git a/fontconfig/src/fcname.c b/fontconfig/src/fcname.c
index f302948dd..466617872 100644
--- a/fontconfig/src/fcname.c
+++ b/fontconfig/src/fcname.c
@@ -87,6 +87,10 @@ FcObjectValidType (FcObject object, FcType type)
if (type == FcTypeLangSet || type == FcTypeString)
return FcTrue;
break;
+ case FcTypeRange:
+ if (type == FcTypeRange || type == FcTypeDouble)
+ return FcTrue;
+ break;
default:
if (type == t->type)
return FcTrue;
@@ -273,6 +277,8 @@ FcNameConvert (FcType type, FcChar8 *string)
{
FcValue v;
FcMatrix m;
+ double b, e;
+ char *p;
v.type = type;
switch ((int) v.type) {
@@ -307,6 +313,20 @@ FcNameConvert (FcType type, FcChar8 *string)
if (!v.u.l)
v.type = FcTypeVoid;
break;
+ case FcTypeRange:
+ if (sscanf ((char *) string, "(%lg %lg)", &b, &e) != 2)
+ {
+ v.u.d = strtod ((char *) string, &p);
+ if (p != NULL && p[0] != 0)
+ {
+ v.type = FcTypeVoid;
+ break;
+ }
+ v.type = FcTypeDouble;
+ }
+ else
+ v.u.r = FcRangeCreateDouble (b, e);
+ break;
default:
break;
}
@@ -476,6 +496,7 @@ FcNameUnparseValue (FcStrBuf *buf,
{
FcChar8 temp[1024];
FcValue v = FcValueCanonicalize(v0);
+ FcRange r;
switch (v.type) {
case FcTypeUnknown:
@@ -501,6 +522,18 @@ FcNameUnparseValue (FcStrBuf *buf,
return FcNameUnparseLangSet (buf, v.u.l);
case FcTypeFTFace:
return FcTrue;
+ case FcTypeRange:
+ r = FcRangeCanonicalize (v.u.r);
+ if (!FcDoubleIsZero (r.u.d.begin) || !FcDoubleIsZero (r.u.d.end))
+ {
+ if (FcDoubleCmpEQ (r.u.d.begin, r.u.d.end))
+ sprintf ((char *) temp, "%g", r.u.d.begin);
+ else
+ sprintf ((char *) temp, "(%g %g)", r.u.d.begin, r.u.d.end);
+ return FcNameUnparseString (buf, temp, 0);
+ }
+ else
+ return FcTrue;
}
return FcFalse;
}
@@ -533,12 +566,13 @@ FcNameUnparse (FcPattern *pat)
FcChar8 *
FcNameUnparseEscaped (FcPattern *pat, FcBool escape)
{
- FcStrBuf buf;
- FcChar8 buf_static[8192];
+ FcStrBuf buf, buf2;
+ FcChar8 buf_static[8192], buf2_static[256];
int i;
FcPatternElt *e;
FcStrBufInit (&buf, buf_static, sizeof (buf_static));
+ FcStrBufInit (&buf2, buf2_static, sizeof (buf2_static));
e = FcPatternObjectFindElt (pat, FC_FAMILY_OBJECT);
if (e)
{
@@ -548,10 +582,17 @@ FcNameUnparseEscaped (FcPattern *pat, FcBool escape)
e = FcPatternObjectFindElt (pat, FC_SIZE_OBJECT);
if (e)
{
- if (!FcNameUnparseString (&buf, (FcChar8 *) "-", 0))
+ FcChar8 *p;
+
+ if (!FcNameUnparseString (&buf2, (FcChar8 *) "-", 0))
goto bail0;
- if (!FcNameUnparseValueList (&buf, FcPatternEltValues(e), escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
+ if (!FcNameUnparseValueList (&buf2, FcPatternEltValues(e), escape ? (FcChar8 *) FC_ESCAPE_FIXED : 0))
goto bail0;
+ p = FcStrBufDoneStatic (&buf2);
+ FcStrBufDestroy (&buf2);
+ if (strlen ((const char *)p) > 1)
+ if (!FcStrBufString (&buf, p))
+ goto bail0;
}
for (i = 0; i < NUM_OBJECT_TYPES; i++)
{
diff --git a/fontconfig/src/fcobjs.h b/fontconfig/src/fcobjs.h
index a0ee0795b..72e71f99c 100644
--- a/fontconfig/src/fcobjs.h
+++ b/fontconfig/src/fcobjs.h
@@ -31,7 +31,7 @@ FC_OBJECT (FULLNAMELANG, FcTypeString, NULL)
FC_OBJECT (SLANT, FcTypeInteger, FcCompareNumber)
FC_OBJECT (WEIGHT, FcTypeInteger, FcCompareNumber)
FC_OBJECT (WIDTH, FcTypeInteger, FcCompareNumber)
-FC_OBJECT (SIZE, FcTypeDouble, NULL)
+FC_OBJECT (SIZE, FcTypeRange, FcCompareSizeRange)
FC_OBJECT (ASPECT, FcTypeDouble, NULL)
FC_OBJECT (PIXEL_SIZE, FcTypeDouble, FcCompareSize)
FC_OBJECT (SPACING, FcTypeInteger, FcCompareNumber)
diff --git a/fontconfig/src/fcpat.c b/fontconfig/src/fcpat.c
index 986cca391..7e7d54a4e 100644
--- a/fontconfig/src/fcpat.c
+++ b/fontconfig/src/fcpat.c
@@ -57,6 +57,9 @@ FcValueDestroy (FcValue v)
case FcTypeLangSet:
FcLangSetDestroy ((FcLangSet *) v.u.l);
break;
+ case FcTypeRange:
+ FcRangeDestroy ((FcRange *) v.u.r);
+ break;
default:
break;
}
@@ -81,6 +84,10 @@ FcValueCanonicalize (const FcValue *v)
new.u.l = FcValueLangSet(v);
new.type = FcTypeLangSet;
break;
+ case FcTypeRange:
+ new.u.r = FcValueRange(v);
+ new.type = FcTypeRange;
+ break;
default:
new = *v;
break;
@@ -112,6 +119,11 @@ FcValueSave (FcValue v)
if (!v.u.l)
v.type = FcTypeVoid;
break;
+ case FcTypeRange:
+ v.u.r = FcRangeCopy (v.u.r);
+ if (!v.u.r)
+ v.type = FcTypeVoid;
+ break;
default:
break;
}
@@ -145,6 +157,9 @@ FcValueListDestroy (FcValueListPtr l)
FcLangSetDestroy
((FcLangSet *) (l->value.u.l));
break;
+ case FcTypeRange:
+ FcRangeDestroy ((FcRange *) (l->value.u.r));
+ break;
default:
break;
}
@@ -267,6 +282,8 @@ FcValueEqual (FcValue va, FcValue vb)
return va.u.f == vb.u.f;
case FcTypeLangSet:
return FcLangSetEqual (va.u.l, vb.u.l);
+ case FcTypeRange:
+ return FcRangeIsInRange (va.u.r, vb.u.r);
}
return FcFalse;
}
@@ -320,6 +337,8 @@ FcValueHash (const FcValue *v)
FcStringHash ((const FcChar8 *) ((FT_Face) v->u.f)->style_name);
case FcTypeLangSet:
return FcLangSetHash (FcValueLangSet(v));
+ case FcTypeRange:
+ return FcRangeHash (v->u.r);
}
return 0;
}
@@ -841,6 +860,22 @@ FcPatternAddLangSet (FcPattern *p, const char *object, const FcLangSet *ls)
return FcPatternAdd (p, object, v, FcTrue);
}
+FcBool
+FcPatternObjectAddRange (FcPattern *p, FcObject object, const FcRange *r)
+{
+ FcValue v;
+
+ v.type = FcTypeRange;
+ v.u.r = (FcRange *)r;
+ return FcPatternObjectAdd (p, object, v, FcTrue);
+}
+
+FcBool
+FcPatternAddRange (FcPattern *p, const char *object, const FcRange *r)
+{
+ return FcPatternObjectAddRange (p, FcObjectFromName (object), r);
+}
+
FcResult
FcPatternObjectGet (const FcPattern *p, FcObject object, int id, FcValue *v)
{
@@ -1025,6 +1060,31 @@ FcPatternGetLangSet(const FcPattern *p, const char *object, int id, FcLangSet **
return FcResultMatch;
}
+FcResult
+FcPatternObjectGetRange (const FcPattern *p, FcObject object, int id, FcRange **r)
+{
+ FcValue v;
+ FcResult res;
+
+ res = FcPatternObjectGet (p, object, id, &v);
+ if (res != FcResultMatch)
+ return res;
+ switch ((int)v.type) {
+ case FcTypeRange:
+ *r = (FcRange *)v.u.r;
+ break;
+ default:
+ return FcResultTypeMismatch;
+ }
+ return FcResultMatch;
+}
+
+FcResult
+FcPatternGetRange (const FcPattern *p, const char *object, int id, FcRange **r)
+{
+ return FcPatternObjectGetRange (p, FcObjectFromName (object), id, r);
+}
+
FcPattern *
FcPatternDuplicate (const FcPattern *orig)
{
@@ -1230,6 +1290,10 @@ FcValueListSerializeAlloc (FcSerialize *serialize, const FcValueList *vl)
if (!FcLangSetSerializeAlloc (serialize, vl->value.u.l))
return FcFalse;
break;
+ case FcTypeRange:
+ if (!FcRangeSerializeAlloc (serialize, vl->value.u.r))
+ return FcFalse;
+ break;
default:
break;
}
@@ -1245,6 +1309,7 @@ FcValueListSerialize (FcSerialize *serialize, const FcValueList *vl)
FcChar8 *s_serialized;
FcCharSet *c_serialized;
FcLangSet *l_serialized;
+ FcRange *r_serialized;
FcValueList *head_serialized = NULL;
FcValueList *prev_serialized = NULL;
@@ -1303,6 +1368,14 @@ FcValueListSerialize (FcSerialize *serialize, const FcValueList *vl)
l_serialized,
FcLangSet);
break;
+ case FcTypeRange:
+ r_serialized = FcRangeSerialize (serialize, vl->value.u.r);
+ if (!r_serialized)
+ return NULL;
+ vl_serialized->value.u.r = FcPtrToEncodedOffset (&vl_serialized->value,
+ r_serialized,
+ FcRange);
+ break;
default:
break;
}
diff --git a/fontconfig/src/fcrange.c b/fontconfig/src/fcrange.c
new file mode 100644
index 000000000..7d0c1c0b1
--- /dev/null
+++ b/fontconfig/src/fcrange.c
@@ -0,0 +1,207 @@
+/*
+ * fontconfig/src/fcrange.c
+ *
+ * Copyright © 2002 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the author(s) not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission. The authors make no
+ * representations about the suitability of this software for any purpose. It
+ * is provided "as is" without express or implied warranty.
+ *
+ * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "fcint.h"
+
+
+FcRange *
+FcRangeCreateDouble (double begin, double end)
+{
+ FcRange *ret = malloc (sizeof (FcRange));
+
+ if (ret)
+ {
+ ret->is_double = FcTrue;
+ ret->is_inclusive = FcDoubleCmpEQ (begin, end);
+ ret->u.d.begin = begin;
+ ret->u.d.end = end;
+ }
+
+ return ret;
+}
+
+FcRange *
+FcRangeCreateInteger (FcChar32 begin, FcChar32 end)
+{
+ FcRange *ret = malloc (sizeof (FcRange));
+
+ if (ret)
+ {
+ ret->is_double = FcFalse;
+ ret->is_inclusive = (begin == end);
+ ret->u.i.begin = begin;
+ ret->u.i.end = end;
+ }
+
+ return ret;
+}
+
+void
+FcRangeDestroy (FcRange *range)
+{
+ free (range);
+}
+
+FcRange *
+FcRangeCopy (const FcRange *range)
+{
+ FcRange *ret;
+
+ if (range->is_double)
+ ret = FcRangeCreateDouble (range->u.d.begin, range->u.d.end);
+ else
+ ret = FcRangeCreateInteger (range->u.i.begin, range->u.i.end);
+
+ return ret;
+}
+
+FcRange
+FcRangeCanonicalize (const FcRange *range)
+{
+ FcRange new;
+
+ if (range->is_double)
+ new = *range;
+ else
+ {
+ new.is_double = FcTrue;
+ new.is_inclusive = range->is_inclusive;
+ new.u.d.begin = (double)range->u.i.begin;
+ new.u.d.end = (double)range->u.i.end;
+ }
+ return new;
+}
+
+FcRange *
+FcRangePromote (double v, FcValuePromotionBuffer *vbuf)
+{
+ typedef struct {
+ FcRange r;
+ } FcRangePromotionBuffer;
+ FcRangePromotionBuffer *buf = (FcRangePromotionBuffer *) vbuf;
+
+ FC_ASSERT_STATIC (sizeof (FcRangePromotionBuffer) <= sizeof (FcValuePromotionBuffer));
+ buf->r.is_double = FcTrue;
+ buf->r.is_inclusive = FcTrue;
+ buf->r.u.d.begin = v;
+ buf->r.u.d.end = v;
+
+ return &buf->r;
+}
+
+FcBool
+FcRangeIsZero (const FcRange *r)
+{
+ FcRange c;
+
+ if (!r)
+ return FcFalse;
+ c = FcRangeCanonicalize (r);
+
+ return FcDoubleIsZero (c.u.d.begin) && FcDoubleIsZero (c.u.d.end);
+}
+
+FcBool
+FcRangeIsInRange (const FcRange *a, const FcRange *b)
+{
+ FcRange ca, cb;
+ FcBool f;
+
+ if (!a || !b)
+ return FcFalse;
+
+ ca = FcRangeCanonicalize (a);
+ cb = FcRangeCanonicalize (b);
+ if (ca.is_inclusive & cb.is_inclusive)
+ f = ca.u.d.end <= cb.u.d.end;
+ else
+ f = ca.u.d.end < cb.u.d.end;
+
+ return FcDoubleCmpGE (ca.u.d.begin, cb.u.d.begin) && f;
+}
+
+FcBool
+FcRangeCompare (FcOp op, const FcRange *a, const FcRange *b)
+{
+ FcRange ca, cb;
+
+ switch ((int) op) {
+ case FcOpEqual:
+ case FcOpContains:
+ case FcOpListing:
+ return FcRangeIsInRange (a, b);
+ case FcOpNotEqual:
+ case FcOpNotContains:
+ return !FcRangeIsInRange (a, b);
+ case FcOpLess:
+ ca = FcRangeCanonicalize (a);
+ cb = FcRangeCanonicalize (b);
+ return ca.u.d.begin < cb.u.d.begin;
+ case FcOpLessEqual:
+ ca = FcRangeCanonicalize (a);
+ cb = FcRangeCanonicalize (b);
+ return FcDoubleCmpLE (ca.u.d.begin, cb.u.d.begin);
+ case FcOpMore:
+ ca = FcRangeCanonicalize (a);
+ cb = FcRangeCanonicalize (b);
+ return ca.u.d.end > cb.u.d.end;
+ case FcOpMoreEqual:
+ ca = FcRangeCanonicalize (a);
+ cb = FcRangeCanonicalize (b);
+ return FcDoubleCmpGE (ca.u.d.end, cb.u.d.end);
+ default:
+ break;
+ }
+ return FcFalse;
+}
+
+FcChar32
+FcRangeHash (const FcRange *r)
+{
+ FcRange c = FcRangeCanonicalize (r);
+ int b = (int) (c.u.d.begin * 100);
+ int e = (int) (c.u.d.end * 100);
+
+ return b ^ (b << 1) ^ (e << 9);
+}
+
+FcBool
+FcRangeSerializeAlloc (FcSerialize *serialize, const FcRange *r)
+{
+ if (!FcSerializeAlloc (serialize, r, sizeof (FcRange)))
+ return FcFalse;
+ return FcTrue;
+}
+
+FcRange *
+FcRangeSerialize (FcSerialize *serialize, const FcRange *r)
+{
+ FcRange *r_serialize = FcSerializePtr (serialize, r);
+
+ if (!r_serialize)
+ return NULL;
+ memcpy (r_serialize, r, sizeof (FcRange));
+
+ return r_serialize;
+}
diff --git a/fontconfig/src/fcxml.c b/fontconfig/src/fcxml.c
index 91d166f38..c68b0cfce 100644
--- a/fontconfig/src/fcxml.c
+++ b/fontconfig/src/fcxml.c
@@ -169,6 +169,18 @@ FcExprCreateMatrix (FcConfig *config, const FcExprMatrix *matrix)
}
static FcExpr *
+FcExprCreateRange (FcConfig *config, FcRange *range)
+{
+ FcExpr *e = FcConfigAllocExpr (config);
+ if (e)
+ {
+ e->op = FcOpRange;
+ e->u.rval = FcRangeCopy (range);
+ }
+ return e;
+}
+
+static FcExpr *
FcExprCreateBool (FcConfig *config, FcBool b)
{
FcExpr *e = FcConfigAllocExpr (config);
@@ -258,6 +270,7 @@ FcExprDestroy (FcExpr *e)
FcExprMatrixFree (e->u.mexpr);
break;
case FcOpRange:
+ FcRangeDestroy (e->u.rval);
break;
case FcOpCharSet:
FcCharSetDestroy (e->u.cval);
@@ -503,7 +516,7 @@ typedef struct _FcVStack {
int integer;
double _double;
FcExprMatrix *matrix;
- FcRange range;
+ FcRange *range;
FcBool bool_;
FcCharSet *charset;
FcLangSet *langset;
@@ -593,6 +606,8 @@ FcTypeName (FcType type)
return "FT_Face";
case FcTypeLangSet:
return "langset";
+ case FcTypeRange:
+ return "range";
default:
return "unknown";
}
@@ -608,7 +623,9 @@ FcTypecheckValue (FcConfigParse *parse, FcType value, FcType type)
if (value != type)
{
if ((value == FcTypeLangSet && type == FcTypeString) ||
- (value == FcTypeString && type == FcTypeLangSet))
+ (value == FcTypeString && type == FcTypeLangSet) ||
+ (value == FcTypeInteger && type == FcTypeRange) ||
+ (value == FcTypeDouble && type == FcTypeRange))
return;
if (type == FcTypeUnknown)
return;
@@ -651,6 +668,9 @@ FcTypecheckExpr (FcConfigParse *parse, FcExpr *expr, FcType type)
case FcOpLangSet:
FcTypecheckValue (parse, FcTypeLangSet, type);
break;
+ case FcOpRange:
+ FcTypecheckValue (parse, FcTypeRange, type);
+ break;
case FcOpNil:
break;
case FcOpField:
@@ -865,11 +885,10 @@ FcVStackPushMatrix (FcConfigParse *parse, FcExprMatrix *matrix)
static FcBool
FcVStackPushRange (FcConfigParse *parse, FcRange *range)
{
- FcVStack *vstack = FcVStackCreateAndPush (parse);
+ FcVStack *vstack = FcVStackCreateAndPush (parse);
if (!vstack)
return FcFalse;
- vstack->u.range.begin = range->begin;
- vstack->u.range.end = range->end;
+ vstack->u.range = range;
vstack->tag = FcVStackRange;
return FcTrue;
}
@@ -1017,9 +1036,11 @@ FcVStackPopAndDestroy (FcConfigParse *parse)
case FcVStackMatrix:
FcExprMatrixFreeShallow (vstack->u.matrix);
break;
- case FcVStackRange:
case FcVStackBool:
break;
+ case FcVStackRange:
+ FcRangeDestroy (vstack->u.range);
+ break;
case FcVStackCharSet:
FcCharSetDestroy (vstack->u.charset);
break;
@@ -1232,7 +1253,9 @@ static void
FcParseBlank (FcConfigParse *parse)
{
int n = FcVStackElements (parse);
- FcChar32 i;
+ FcChar32 i, begin, end;
+ FcRange r;
+
while (n-- > 0)
{
FcVStack *v = FcVStackFetch (parse, n);
@@ -1248,9 +1271,12 @@ FcParseBlank (FcConfigParse *parse)
goto bail;
break;
case FcVStackRange:
- if (v->u.range.begin <= v->u.range.end)
+ r = FcRangeCanonicalize (v->u.range);
+ begin = (FcChar32)r.u.d.begin;
+ end = (FcChar32)r.u.d.end;
+ if (begin <= end)
{
- for (i = v->u.range.begin; i <= v->u.range.end; i++)
+ for (i = begin; i <= end; i++)
{
if (!FcBlanksAdd (parse->config->blanks, i))
goto bail;
@@ -1463,9 +1489,11 @@ static void
FcParseRange (FcConfigParse *parse)
{
FcVStack *vstack;
- FcRange r = {0, 0};
- FcChar32 n;
+ FcRange *r;
+ FcChar32 n[2] = {0, 0};
int count = 1;
+ double d[2] = {0.0L, 0.0L};
+ FcBool dflag = FcFalse;
while ((vstack = FcVStackPeek (parse)))
{
@@ -1476,31 +1504,52 @@ FcParseRange (FcConfigParse *parse)
}
switch ((int) vstack->tag) {
case FcVStackInteger:
- n = vstack->u.integer;
+ if (dflag)
+ d[count] = (double)vstack->u.integer;
+ else
+ n[count] = vstack->u.integer;
+ break;
+ case FcVStackDouble:
+ if (count == 0 && !dflag)
+ d[1] = (double)n[1];
+ d[count] = vstack->u._double;
+ dflag = FcTrue;
break;
default:
FcConfigMessage (parse, FcSevereError, "invalid element in range");
- n = 0;
+ if (dflag)
+ d[count] = 0.0L;
+ else
+ n[count] = 0;
break;
}
- if (count == 1)
- r.end = n;
- else
- r.begin = n;
count--;
FcVStackPopAndDestroy (parse);
}
- if (count < 0)
+ if (count >= 0)
+ {
+ FcConfigMessage (parse, FcSevereError, "invalid range");
+ return;
+ }
+ if (dflag)
{
- if (r.begin > r.end)
+ if (d[0] > d[1])
{
FcConfigMessage (parse, FcSevereError, "invalid range");
return;
}
- FcVStackPushRange (parse, &r);
+ r = FcRangeCreateDouble (d[0], d[1]);
}
else
- FcConfigMessage (parse, FcSevereError, "invalid range");
+ {
+ if (n[0] > n[1])
+ {
+ FcConfigMessage (parse, FcSevereError, "invalid range");
+ return;
+ }
+ r = FcRangeCreateInteger (n[0], n[1]);
+ }
+ FcVStackPushRange (parse, r);
}
static FcBool
@@ -1536,7 +1585,8 @@ FcParseCharSet (FcConfigParse *parse)
{
FcVStack *vstack;
FcCharSet *charset = FcCharSetCreate ();
- FcChar32 i;
+ FcChar32 i, begin, end;
+ FcRange r;
int n = 0;
while ((vstack = FcVStackPeek (parse)))
@@ -1551,9 +1601,13 @@ FcParseCharSet (FcConfigParse *parse)
n++;
break;
case FcVStackRange:
- if (vstack->u.range.begin <= vstack->u.range.end)
+ r = FcRangeCanonicalize (vstack->u.range);
+ begin = (FcChar32)r.u.d.begin;
+ end = (FcChar32)r.u.d.end;
+
+ if (begin <= end)
{
- for (i = vstack->u.range.begin; i <= vstack->u.range.end; i++)
+ for (i = begin; i <= end; i++)
{
if (!FcCharSetAddChar (charset, i))
{
@@ -1888,6 +1942,7 @@ FcPopExpr (FcConfigParse *parse)
expr = FcExprCreateMatrix (parse->config, vstack->u.matrix);
break;
case FcVStackRange:
+ expr = FcExprCreateRange (parse->config, vstack->u.range);
break;
case FcVStackBool:
expr = FcExprCreateBool (parse->config, vstack->u.bool_);
@@ -2653,6 +2708,11 @@ FcPopValue (FcConfigParse *parse)
if (value.u.l)
value.type = FcTypeLangSet;
break;
+ case FcVStackRange:
+ value.u.r = FcRangeCopy (vstack->u.range);
+ if (value.u.r)
+ value.type = FcTypeRange;
+ break;
default:
FcConfigMessage (parse, FcSevereWarning, "unknown pattern element %d",
vstack->tag);
diff --git a/mesalib/SConstruct b/mesalib/SConstruct
index de735e94c..0e10818ba 100644
--- a/mesalib/SConstruct
+++ b/mesalib/SConstruct
@@ -59,13 +59,6 @@ else:
Help(opts.GenerateHelpText(env))
-# fail early for a common error on windows
-if env['gles']:
- try:
- import libxml2
- except ImportError:
- raise SCons.Errors.UserError, "GLES requires libxml2-python to build"
-
#######################################################################
# Environment setup
diff --git a/mesalib/configure.ac b/mesalib/configure.ac
index c5042f93e..1e5e49667 100644
--- a/mesalib/configure.ac
+++ b/mesalib/configure.ac
@@ -54,7 +54,6 @@ AM_PROG_CC_C_O
AM_PROG_AS
AC_CHECK_PROGS([MAKE], [gmake make])
AC_CHECK_PROGS([PYTHON2], [python2 python])
-AX_PYTHON_MODULE([libxml2], [needed])
AC_PROG_SED
AC_PROG_MKDIR_P
@@ -1549,7 +1548,6 @@ if test "x$enable_gallium_llvm" = xyes; then
LLVM_CXXFLAGS=`strip_unwanted_llvm_flags "$LLVM_CONFIG --cxxflags"`
LLVM_INCLUDEDIR=`$LLVM_CONFIG --includedir`
LLVM_LIBDIR=`$LLVM_CONFIG --libdir`
- LLVM_LDFLAGS="-Wl,-rpath,$LLVM_LIBDIR $LLVM_LDFLAGS"
AC_COMPUTE_INT([LLVM_VERSION_MAJOR], [LLVM_VERSION_MAJOR],
[#include "${LLVM_INCLUDEDIR}/llvm/Config/llvm-config.h"])
diff --git a/mesalib/docs/README.WIN32 b/mesalib/docs/README.WIN32
index 0cd007c8a..c8759f65b 100644
--- a/mesalib/docs/README.WIN32
+++ b/mesalib/docs/README.WIN32
@@ -36,17 +36,15 @@ Recipe
Building on windows requires several open-source packages. These are
steps that work as of this writing.
-1) install python 2.7
-2) install scons (latest)
-3) install mingw, flex, and bison
-4) install libxml2 from here: http://www.lfd.uci.edu/~gohlke/pythonlibs
- get libxml2-python-2.9.1.win-amd64-py2.7.exe
-5) install pywin32 from here: http://www.lfd.uci.edu/~gohlke/pythonlibs
+- install python 2.7
+- install scons (latest)
+- install mingw, flex, and bison
+- install pywin32 from here: http://www.lfd.uci.edu/~gohlke/pythonlibs
get pywin32-218.4.win-amd64-py2.7.exe
-6) install git
-7) download mesa from git
+- install git
+- download mesa from git
see http://www.mesa3d.org/repository.html
-8) run scons
+- run scons
General
-------
diff --git a/mesalib/docs/install.html b/mesalib/docs/install.html
index 24492a786..5061eded0 100644
--- a/mesalib/docs/install.html
+++ b/mesalib/docs/install.html
@@ -44,10 +44,6 @@ On Windows with MinGW, install flex and bison with:
</li>
<li>python - Python is needed for building the Gallium components.
Version 2.6.4 or later should work.
-<br>
-<br>
-To build OpenGL ES 1.1 and 2.0 you'll also need
-<a href="http://xmlsoft.org/sources/win32/python/libxml2-python-2.7.7.win32-py2.7.exe">libxml2-python</a>.
</li>
</ul>
diff --git a/mesalib/m4/ax_python_module.m4 b/mesalib/m4/ax_python_module.m4
deleted file mode 100644
index 2e6670a0f..000000000
--- a/mesalib/m4/ax_python_module.m4
+++ /dev/null
@@ -1,49 +0,0 @@
-# ===========================================================================
-# http://www.gnu.org/software/autoconf-archive/ax_python_module.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-# AX_PYTHON_MODULE(modname[, fatal])
-#
-# DESCRIPTION
-#
-# Checks for Python module.
-#
-# If fatal is non-empty then absence of a module will trigger an error.
-#
-# LICENSE
-#
-# Copyright (c) 2008 Andrew Collier
-#
-# Copying and distribution of this file, with or without modification, are
-# permitted in any medium without royalty provided the copyright notice
-# and this notice are preserved. This file is offered as-is, without any
-# warranty.
-
-#serial 6
-
-AU_ALIAS([AC_PYTHON_MODULE], [AX_PYTHON_MODULE])
-AC_DEFUN([AX_PYTHON_MODULE],[
- if test -z $PYTHON2;
- then
- PYTHON2="python"
- fi
- PYTHON_NAME=`basename $PYTHON2`
- AC_MSG_CHECKING($PYTHON_NAME module: $1)
- $PYTHON2 -c "import $1" 2>/dev/null
- if test $? -eq 0;
- then
- AC_MSG_RESULT(yes)
- eval AS_TR_CPP(HAVE_PYMOD_$1)=yes
- else
- AC_MSG_RESULT(no)
- eval AS_TR_CPP(HAVE_PYMOD_$1)=no
- #
- if test -n "$2"
- then
- AC_MSG_ERROR(failed to find required module $1)
- exit 1
- fi
- fi
-])
diff --git a/mesalib/src/glsl/glsl_parser.yy b/mesalib/src/glsl/glsl_parser.yy
index faaf4388c..2d0e7be54 100644
--- a/mesalib/src/glsl/glsl_parser.yy
+++ b/mesalib/src/glsl/glsl_parser.yy
@@ -1901,7 +1901,6 @@ struct_specifier:
$$ = new(ctx) ast_struct_specifier($2, $4);
$$->set_location_range(@2, @5);
state->symbols->add_type($2, glsl_type::void_type);
- state->symbols->add_type_ast($2, new(ctx) ast_type_specifier($$));
}
| STRUCT '{' struct_declaration_list '}'
{
diff --git a/mesalib/src/glsl/glsl_symbol_table.cpp b/mesalib/src/glsl/glsl_symbol_table.cpp
index 11569f47e..a05236203 100644
--- a/mesalib/src/glsl/glsl_symbol_table.cpp
+++ b/mesalib/src/glsl/glsl_symbol_table.cpp
@@ -162,23 +162,6 @@ bool glsl_symbol_table::add_type(const char *name, const glsl_type *t)
return _mesa_symbol_table_add_symbol(table, -1, name, entry) == 0;
}
-static char *make_ast_name(const char *name)
-{
- char *ast_name = new char[strlen("#ast.") + strlen(name) + 1];
- strcpy(ast_name, "#ast.");
- strcat(ast_name + strlen("#ast."), name);
- return ast_name;
-}
-
-bool glsl_symbol_table::add_type_ast(const char *name, const class ast_type_specifier *a)
-{
- symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(a);
- char *ast_name = make_ast_name(name);
- bool ret = _mesa_symbol_table_add_symbol(table, -1, ast_name, entry) == 0;
- delete [] ast_name;
- return ret;
-}
-
bool glsl_symbol_table::add_interface(const char *name, const glsl_type *i,
enum ir_variable_mode mode)
{
@@ -230,14 +213,6 @@ const glsl_type *glsl_symbol_table::get_type(const char *name)
return entry != NULL ? entry->t : NULL;
}
-const class ast_type_specifier *glsl_symbol_table::get_type_ast(const char *name)
-{
- char *ast_name = make_ast_name(name);
- symbol_table_entry *entry = get_entry(ast_name);
- delete [] ast_name;
- return entry != NULL ? entry->a : NULL;
-}
-
const glsl_type *glsl_symbol_table::get_interface(const char *name,
enum ir_variable_mode mode)
{
diff --git a/mesalib/src/glsl/glsl_symbol_table.h b/mesalib/src/glsl/glsl_symbol_table.h
index 0e62448e2..f323fc305 100644
--- a/mesalib/src/glsl/glsl_symbol_table.h
+++ b/mesalib/src/glsl/glsl_symbol_table.h
@@ -98,7 +98,6 @@ public:
/*@{*/
bool add_variable(ir_variable *v);
bool add_type(const char *name, const glsl_type *t);
- bool add_type_ast(const char *name, const class ast_type_specifier *t);
bool add_function(ir_function *f);
bool add_interface(const char *name, const glsl_type *i,
enum ir_variable_mode mode);
@@ -115,7 +114,6 @@ public:
/*@{*/
ir_variable *get_variable(const char *name);
const glsl_type *get_type(const char *name);
- const class ast_type_specifier *get_type_ast(const char *name);
ir_function *get_function(const char *name);
const glsl_type *get_interface(const char *name,
enum ir_variable_mode mode);
diff --git a/mesalib/src/glsl/ir.h b/mesalib/src/glsl/ir.h
index ed3f086ce..8fa3b9ef6 100644
--- a/mesalib/src/glsl/ir.h
+++ b/mesalib/src/glsl/ir.h
@@ -1914,15 +1914,6 @@ public:
* Get the variable that is ultimately referenced by an r-value
*/
virtual ir_variable *variable_referenced() const = 0;
-
- /**
- * Get the constant that is ultimately referenced by an r-value,
- * in a constant expression evaluation context.
- *
- * The offset is used when the reference is to a specific column of
- * a matrix.
- */
- virtual void constant_referenced(struct hash_table *variable_context, ir_constant *&store, int &offset) const = 0;
};
@@ -1950,15 +1941,6 @@ public:
return this->var;
}
- /**
- * Get the constant that is ultimately referenced by an r-value,
- * in a constant expression evaluation context.
- *
- * The offset is used when the reference is to a specific column of
- * a matrix.
- */
- virtual void constant_referenced(struct hash_table *variable_context, ir_constant *&store, int &offset) const;
-
virtual ir_variable *whole_variable_referenced()
{
/* ir_dereference_variable objects always dereference the entire
@@ -2010,15 +1992,6 @@ public:
return this->array->variable_referenced();
}
- /**
- * Get the constant that is ultimately referenced by an r-value,
- * in a constant expression evaluation context.
- *
- * The offset is used when the reference is to a specific column of
- * a matrix.
- */
- virtual void constant_referenced(struct hash_table *variable_context, ir_constant *&store, int &offset) const;
-
virtual void accept(ir_visitor *v)
{
v->visit(this);
@@ -2058,15 +2031,6 @@ public:
return this->record->variable_referenced();
}
- /**
- * Get the constant that is ultimately referenced by an r-value,
- * in a constant expression evaluation context.
- *
- * The offset is used when the reference is to a specific column of
- * a matrix.
- */
- virtual void constant_referenced(struct hash_table *variable_context, ir_constant *&store, int &offset) const;
-
virtual void accept(ir_visitor *v)
{
v->visit(this);
diff --git a/mesalib/src/glsl/ir_clone.cpp b/mesalib/src/glsl/ir_clone.cpp
index 311c992be..167b80c9f 100644
--- a/mesalib/src/glsl/ir_clone.cpp
+++ b/mesalib/src/glsl/ir_clone.cpp
@@ -265,10 +265,12 @@ ir_assignment::clone(void *mem_ctx, struct hash_table *ht) const
if (this->condition)
new_condition = this->condition->clone(mem_ctx, ht);
- return new(mem_ctx) ir_assignment(this->lhs->clone(mem_ctx, ht),
- this->rhs->clone(mem_ctx, ht),
- new_condition,
- this->write_mask);
+ ir_assignment *cloned =
+ new(mem_ctx) ir_assignment(this->lhs->clone(mem_ctx, ht),
+ this->rhs->clone(mem_ctx, ht),
+ new_condition);
+ cloned->write_mask = this->write_mask;
+ return cloned;
}
ir_function *
diff --git a/mesalib/src/glsl/ir_constant_expression.cpp b/mesalib/src/glsl/ir_constant_expression.cpp
index 7fa5a09d4..8afe8f776 100644
--- a/mesalib/src/glsl/ir_constant_expression.cpp
+++ b/mesalib/src/glsl/ir_constant_expression.cpp
@@ -386,8 +386,104 @@ unpack_half_1x16(uint16_t u)
return _mesa_half_to_float(u);
}
+/**
+ * Get the constant that is ultimately referenced by an r-value, in a constant
+ * expression evaluation context.
+ *
+ * The offset is used when the reference is to a specific column of a matrix.
+ */
+static bool
+constant_referenced(const ir_dereference *deref,
+ struct hash_table *variable_context,
+ ir_constant *&store, int &offset)
+{
+ store = NULL;
+ offset = 0;
+
+ if (variable_context == NULL)
+ return false;
+
+ switch (deref->ir_type) {
+ case ir_type_dereference_array: {
+ const ir_dereference_array *const da =
+ (const ir_dereference_array *) deref;
+
+ ir_constant *const index_c =
+ da->array_index->constant_expression_value(variable_context);
+
+ if (!index_c || !index_c->type->is_scalar() || !index_c->type->is_integer())
+ break;
+
+ const int index = index_c->type->base_type == GLSL_TYPE_INT ?
+ index_c->get_int_component(0) :
+ index_c->get_uint_component(0);
+
+ ir_constant *substore;
+ int suboffset;
+
+ const ir_dereference *const deref = da->array->as_dereference();
+ if (!deref)
+ break;
+
+ if (!constant_referenced(deref, variable_context, substore, suboffset))
+ break;
+
+ const glsl_type *const vt = da->array->type;
+ if (vt->is_array()) {
+ store = substore->get_array_element(index);
+ offset = 0;
+ } else if (vt->is_matrix()) {
+ store = substore;
+ offset = index * vt->vector_elements;
+ } else if (vt->is_vector()) {
+ store = substore;
+ offset = suboffset + index;
+ }
+
+ break;
+ }
+
+ case ir_type_dereference_record: {
+ const ir_dereference_record *const dr =
+ (const ir_dereference_record *) deref;
+
+ const ir_dereference *const deref = dr->record->as_dereference();
+ if (!deref)
+ break;
+
+ ir_constant *substore;
+ int suboffset;
+
+ if (!constant_referenced(deref, variable_context, substore, suboffset))
+ break;
+
+ /* Since we're dropping it on the floor...
+ */
+ assert(suboffset == 0);
+
+ store = substore->get_record_field(dr->field);
+ break;
+ }
+
+ case ir_type_dereference_variable: {
+ const ir_dereference_variable *const dv =
+ (const ir_dereference_variable *) deref;
+
+ store = (ir_constant *) hash_table_find(variable_context, dv->var);
+ break;
+ }
+
+ default:
+ assert(!"Should not get here.");
+ break;
+ }
+
+ return store != NULL;
+}
+
+
ir_constant *
-ir_rvalue::constant_expression_value(struct hash_table *variable_context)
+ir_rvalue::constant_expression_value(struct hash_table *)
{
assert(this->type->is_error());
return NULL;
@@ -1534,7 +1630,7 @@ ir_expression::constant_expression_value(struct hash_table *variable_context)
ir_constant *
-ir_texture::constant_expression_value(struct hash_table *variable_context)
+ir_texture::constant_expression_value(struct hash_table *)
{
/* texture lookups aren't constant expressions */
return NULL;
@@ -1570,19 +1666,6 @@ ir_swizzle::constant_expression_value(struct hash_table *variable_context)
}
-void
-ir_dereference_variable::constant_referenced(struct hash_table *variable_context,
- ir_constant *&store, int &offset) const
-{
- if (variable_context) {
- store = (ir_constant *)hash_table_find(variable_context, var);
- offset = 0;
- } else {
- store = NULL;
- offset = 0;
- }
-}
-
ir_constant *
ir_dereference_variable::constant_expression_value(struct hash_table *variable_context)
{
@@ -1610,60 +1693,6 @@ ir_dereference_variable::constant_expression_value(struct hash_table *variable_c
}
-void
-ir_dereference_array::constant_referenced(struct hash_table *variable_context,
- ir_constant *&store, int &offset) const
-{
- ir_constant *index_c = array_index->constant_expression_value(variable_context);
-
- if (!index_c || !index_c->type->is_scalar() || !index_c->type->is_integer()) {
- store = 0;
- offset = 0;
- return;
- }
-
- int index = index_c->type->base_type == GLSL_TYPE_INT ?
- index_c->get_int_component(0) :
- index_c->get_uint_component(0);
-
- ir_constant *substore;
- int suboffset;
- const ir_dereference *deref = array->as_dereference();
- if (!deref) {
- store = 0;
- offset = 0;
- return;
- }
-
- deref->constant_referenced(variable_context, substore, suboffset);
-
- if (!substore) {
- store = 0;
- offset = 0;
- return;
- }
-
- const glsl_type *vt = array->type;
- if (vt->is_array()) {
- store = substore->get_array_element(index);
- offset = 0;
- return;
- }
- if (vt->is_matrix()) {
- store = substore;
- offset = index * vt->vector_elements;
- return;
- }
- if (vt->is_vector()) {
- store = substore;
- offset = suboffset + index;
- return;
- }
-
- store = 0;
- offset = 0;
-}
-
ir_constant *
ir_dereference_array::constant_expression_value(struct hash_table *variable_context)
{
@@ -1719,33 +1748,8 @@ ir_dereference_array::constant_expression_value(struct hash_table *variable_cont
}
-void
-ir_dereference_record::constant_referenced(struct hash_table *variable_context,
- ir_constant *&store, int &offset) const
-{
- ir_constant *substore;
- int suboffset;
- const ir_dereference *deref = record->as_dereference();
- if (!deref) {
- store = 0;
- offset = 0;
- return;
- }
-
- deref->constant_referenced(variable_context, substore, suboffset);
-
- if (!substore) {
- store = 0;
- offset = 0;
- return;
- }
-
- store = substore->get_record_field(field);
- offset = 0;
-}
-
ir_constant *
-ir_dereference_record::constant_expression_value(struct hash_table *variable_context)
+ir_dereference_record::constant_expression_value(struct hash_table *)
{
ir_constant *v = this->record->constant_expression_value();
@@ -1754,7 +1758,7 @@ ir_dereference_record::constant_expression_value(struct hash_table *variable_con
ir_constant *
-ir_assignment::constant_expression_value(struct hash_table *variable_context)
+ir_assignment::constant_expression_value(struct hash_table *)
{
/* FINISHME: Handle CEs involving assignment (return RHS) */
return NULL;
@@ -1762,7 +1766,7 @@ ir_assignment::constant_expression_value(struct hash_table *variable_context)
ir_constant *
-ir_constant::constant_expression_value(struct hash_table *variable_context)
+ir_constant::constant_expression_value(struct hash_table *)
{
return this;
}
@@ -1803,9 +1807,8 @@ bool ir_function_signature::constant_expression_evaluate_expression_list(const s
ir_constant *store = NULL;
int offset = 0;
- asg->lhs->constant_referenced(variable_context, store, offset);
- if (!store)
+ if (!constant_referenced(asg->lhs, variable_context, store, offset))
return false;
ir_constant *value = asg->rhs->constant_expression_value(variable_context);
@@ -1836,9 +1839,9 @@ bool ir_function_signature::constant_expression_evaluate_expression_list(const s
ir_constant *store = NULL;
int offset = 0;
- call->return_deref->constant_referenced(variable_context, store, offset);
- if (!store)
+ if (!constant_referenced(call->return_deref, variable_context,
+ store, offset))
return false;
ir_constant *value = call->constant_expression_value(variable_context);
diff --git a/mesalib/src/mapi/glapi/gen/glX_XML.py b/mesalib/src/mapi/glapi/gen/glX_XML.py
index 03a35b740..12ff291fc 100644
--- a/mesalib/src/mapi/glapi/gen/glX_XML.py
+++ b/mesalib/src/mapi/glapi/gen/glX_XML.py
@@ -33,29 +33,27 @@ import sys, getopt, string
class glx_item_factory(gl_XML.gl_item_factory):
"""Factory to create GLX protocol oriented objects derived from gl_item."""
- def create_item(self, name, element, context):
- if name == "function":
- return glx_function(element, context)
- elif name == "enum":
- return glx_enum(element, context)
- elif name == "api":
- return glx_api(self)
- else:
- return gl_XML.gl_item_factory.create_item(self, name, element, context)
+ def create_function(self, element, context):
+ return glx_function(element, context)
+
+ def create_enum(self, element, context, category):
+ return glx_enum(element, context, category)
+
+ def create_api(self):
+ return glx_api(self)
class glx_enum(gl_XML.gl_enum):
- def __init__(self, element, context):
- gl_XML.gl_enum.__init__(self, element, context)
+ def __init__(self, element, context, category):
+ gl_XML.gl_enum.__init__(self, element, context, category)
self.functions = {}
- child = element.children
- while child:
- if child.type == "element" and child.name == "size":
- n = child.nsProp( "name", None )
- c = child.nsProp( "count", None )
- m = child.nsProp( "mode", None )
+ for child in element.getchildren():
+ if child.tag == "size":
+ n = child.get( "name" )
+ c = child.get( "count" )
+ m = child.get( "mode", "set" )
if not c:
c = self.default_count
@@ -70,8 +68,6 @@ class glx_enum(gl_XML.gl_enum):
if not self.functions.has_key(n):
self.functions[ n ] = [c, mode]
- child = child.next
-
return
@@ -120,10 +116,10 @@ class glx_function(gl_XML.gl_function):
# appears after the function that it aliases.
if not self.vectorequiv:
- self.vectorequiv = element.nsProp("vectorequiv", None)
+ self.vectorequiv = element.get("vectorequiv")
- name = element.nsProp("name", None)
+ name = element.get("name")
if name == self.name:
for param in self.parameters:
self.parameters_by_name[ param.name ] = param
@@ -135,12 +131,11 @@ class glx_function(gl_XML.gl_function):
self.counter_list.append(param.counter)
- child = element.children
- while child:
- if child.type == "element" and child.name == "glx":
- rop = child.nsProp( 'rop', None )
- sop = child.nsProp( 'sop', None )
- vop = child.nsProp( 'vendorpriv', None )
+ for child in element.getchildren():
+ if child.tag == "glx":
+ rop = child.get( 'rop' )
+ sop = child.get( 'sop' )
+ vop = child.get( 'vendorpriv' )
if rop:
self.glx_rop = int(rop)
@@ -152,12 +147,12 @@ class glx_function(gl_XML.gl_function):
self.glx_vendorpriv = int(vop)
self.glx_vendorpriv_names.append(name)
- self.img_reset = child.nsProp( 'img_reset', None )
+ self.img_reset = child.get( 'img_reset' )
# The 'handcode' attribute can be one of 'true',
# 'false', 'client', or 'server'.
- handcode = child.nsProp( 'handcode', None )
+ handcode = child.get( 'handcode', 'false' )
if handcode == "false":
self.server_handcode = 0
self.client_handcode = 0
@@ -179,8 +174,6 @@ class glx_function(gl_XML.gl_function):
self.reply_always_array = gl_XML.is_attr_true( child, 'always_array' )
self.dimensions_in_reply = gl_XML.is_attr_true( child, 'dimensions_in_reply' )
- child = child.next
-
# Do some validation of the GLX protocol information. As
# new tests are discovered, they should be added here.
diff --git a/mesalib/src/mapi/glapi/gen/glX_doc.py b/mesalib/src/mapi/glapi/gen/glX_doc.py
deleted file mode 100644
index 35d068894..000000000
--- a/mesalib/src/mapi/glapi/gen/glX_doc.py
+++ /dev/null
@@ -1,280 +0,0 @@
-#!/usr/bin/env python
-
-# (C) Copyright IBM Corporation 2004, 2005
-# All Rights Reserved.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation
-# on the rights to use, copy, modify, merge, publish, distribute, sub
-# license, and/or sell copies of the Software, and to permit persons to whom
-# the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice (including the next
-# paragraph) shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
-# IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-# Authors:
-# Ian Romanick <idr@us.ibm.com>
-
-import gl_XML, glX_XML, glX_proto_common, license
-import sys, getopt
-
-
-class glx_doc_item_factory(glX_proto_common.glx_proto_item_factory):
- """Factory to create GLX protocol documentation oriented objects derived from glItem."""
-
- def create_item(self, name, element, context):
- if name == "parameter":
- return glx_doc_parameter(element, context)
- else:
- return glX_proto_common.glx_proto_item_factory.create_item(self, name, element, context)
-
-
-class glx_doc_parameter(gl_XML.gl_parameter):
- def packet_type(self, type_dict):
- """Get the type string for the packet header
-
- GLX protocol documentation uses type names like CARD32,
- FLOAT64, LISTofCARD8, and ENUM. This function converts the
- type of the parameter to one of these names."""
-
- list_of = ""
- if self.is_array():
- list_of = "LISTof"
-
- t_name = self.get_base_type_string()
- if not type_dict.has_key( t_name ):
- type_name = "CARD8"
- else:
- type_name = type_dict[ t_name ]
-
- return "%s%s" % (list_of, type_name)
-
-
- def packet_size(self):
- p = None
- s = self.size()
- if s == 0:
- a_prod = "n"
- b_prod = self.p_type.size
-
- if not self.count_parameter_list and self.counter:
- a_prod = self.counter
- elif self.count_parameter_list and not self.counter or self.is_output:
- pass
- elif self.count_parameter_list and self.counter:
- b_prod = self.counter
- else:
- raise RuntimeError("Parameter '%s' to function '%s' has size 0." % (self.name, self.context.name))
-
- ss = "%s*%s" % (a_prod, b_prod)
-
- return [ss, p]
- else:
- if s % 4 != 0:
- p = "p"
-
- return [str(s), p]
-
-class PrintGlxProtoText(gl_XML.gl_print_base):
- def __init__(self):
- gl_XML.gl_print_base.__init__(self)
- self.license = ""
-
-
- def printHeader(self):
- return
-
-
- def body_size(self, f):
- # At some point, refactor this function and
- # glXFunction::command_payload_length.
-
- size = 0;
- size_str = ""
- pad_str = ""
- plus = ""
- for p in f.parameterIterateGlxSend():
- [s, pad] = p.packet_size()
- try:
- size += int(s)
- except Exception,e:
- size_str += "%s%s" % (plus, s)
- plus = "+"
-
- if pad != None:
- pad_str = pad
-
- return [size, size_str, pad_str]
-
-
- def print_render_header(self, f):
- [size, size_str, pad_str] = self.body_size(f)
- size += 4;
-
- if size_str == "":
- s = "%u" % ((size + 3) & ~3)
- elif pad_str != "":
- s = "%u+%s+%s" % (size, size_str, pad_str)
- else:
- s = "%u+%s" % (size, size_str)
-
- print ' 2 %-15s rendering command length' % (s)
- print ' 2 %-4u rendering command opcode' % (f.glx_rop)
- return
-
-
- def print_single_header(self, f):
- [size, size_str, pad_str] = self.body_size(f)
- size = ((size + 3) / 4) + 2;
-
- if f.glx_vendorpriv != 0:
- size += 1
-
- print ' 1 CARD8 opcode (X assigned)'
- print ' 1 %-4u GLX opcode (%s)' % (f.opcode_real_value(), f.opcode_real_name())
-
- if size_str == "":
- s = "%u" % (size)
- elif pad_str != "":
- s = "%u+((%s+%s)/4)" % (size, size_str, pad_str)
- else:
- s = "%u+((%s)/4)" % (size, size_str)
-
- print ' 2 %-15s request length' % (s)
-
- if f.glx_vendorpriv != 0:
- print ' 4 %-4u vendor specific opcode' % (f.opcode_value())
-
- print ' 4 GLX_CONTEXT_TAG context tag'
-
- return
-
-
- def print_reply(self, f):
- print ' =>'
- print ' 1 1 reply'
- print ' 1 unused'
- print ' 2 CARD16 sequence number'
-
- if f.output == None:
- print ' 4 0 reply length'
- elif f.reply_always_array:
- print ' 4 m reply length'
- else:
- print ' 4 m reply length, m = (n == 1 ? 0 : n)'
-
-
- output = None
- for x in f.parameterIterateOutputs():
- output = x
- break
-
-
- unused = 24
- if f.return_type != 'void':
- print ' 4 %-15s return value' % (f.return_type)
- unused -= 4
- elif output != None:
- print ' 4 unused'
- unused -= 4
-
- if output != None:
- print ' 4 CARD32 n'
- unused -= 4
-
- if output != None:
- if not f.reply_always_array:
- print ''
- print ' if (n = 1) this follows:'
- print ''
- print ' 4 CARD32 %s' % (output.name)
- print ' %-2u unused' % (unused - 4)
- print ''
- print ' otherwise this follows:'
- print ''
-
- print ' %-2u unused' % (unused)
-
- [s, pad] = output.packet_size()
- print ' %-8s %-15s %s' % (s, output.packet_type( self.type_map ), output.name)
- if pad != None:
- try:
- bytes = int(s)
- bytes = 4 - (bytes & 3)
- print ' %-8u %-15s unused' % (bytes, "")
- except Exception,e:
- print ' %-8s %-15s unused, %s=pad(%s)' % (pad, "", pad, s)
- else:
- print ' %-2u unused' % (unused)
-
-
- def print_body(self, f):
- for p in f.parameterIterateGlxSend():
- [s, pad] = p.packet_size()
- print ' %-8s %-15s %s' % (s, p.packet_type( self.type_map ), p.name)
- if pad != None:
- try:
- bytes = int(s)
- bytes = 4 - (bytes & 3)
- print ' %-8u %-15s unused' % (bytes, "")
- except Exception,e:
- print ' %-8s %-15s unused, %s=pad(%s)' % (pad, "", pad, s)
-
- def printBody(self, api):
- self.type_map = {}
- for t in api.typeIterate():
- self.type_map[ "GL" + t.name ] = t.glx_name
-
-
- # At some point this should be expanded to support pixel
- # functions, but I'm not going to lose any sleep over it now.
-
- for f in api.functionIterateByOffset():
- if f.client_handcode or f.server_handcode or f.vectorequiv or len(f.get_images()):
- continue
-
-
- if f.glx_rop:
- print ' %s' % (f.name)
- self.print_render_header(f)
- elif f.glx_sop or f.glx_vendorpriv:
- print ' %s' % (f.name)
- self.print_single_header(f)
- else:
- continue
-
- self.print_body(f)
-
- if f.needs_reply():
- self.print_reply(f)
-
- print ''
- return
-
-
-if __name__ == '__main__':
- file_name = "gl_API.xml"
-
- try:
- (args, trail) = getopt.getopt(sys.argv[1:], "f:")
- except Exception,e:
- show_usage()
-
- for (arg,val) in args:
- if arg == "-f":
- file_name = val
-
- api = gl_XML.parse_GL_API( file_name, glx_doc_item_factory() )
-
- printer = PrintGlxProtoText()
- printer.Print( api )
diff --git a/mesalib/src/mapi/glapi/gen/glX_proto_common.py b/mesalib/src/mapi/glapi/gen/glX_proto_common.py
index 86d9189a9..ae2c2d581 100644
--- a/mesalib/src/mapi/glapi/gen/glX_proto_common.py
+++ b/mesalib/src/mapi/glapi/gen/glX_proto_common.py
@@ -32,18 +32,15 @@ import string
class glx_proto_item_factory(glX_XML.glx_item_factory):
"""Factory to create GLX protocol oriented objects derived from gl_item."""
- def create_item(self, name, element, context):
- if name == "type":
- return glx_proto_type(element, context)
- else:
- return glX_XML.glx_item_factory.create_item(self, name, element, context)
+ def create_type(self, element, context, category):
+ return glx_proto_type(element, context, category)
class glx_proto_type(gl_XML.gl_type):
- def __init__(self, element, context):
- gl_XML.gl_type.__init__(self, element, context)
+ def __init__(self, element, context, category):
+ gl_XML.gl_type.__init__(self, element, context, category)
- self.glx_name = element.nsProp( "glx_name", None )
+ self.glx_name = element.get( "glx_name" )
return
diff --git a/mesalib/src/mapi/glapi/gen/gl_XML.py b/mesalib/src/mapi/glapi/gen/gl_XML.py
index 3bbc79439..1a2bc2b91 100644
--- a/mesalib/src/mapi/glapi/gen/gl_XML.py
+++ b/mesalib/src/mapi/glapi/gen/gl_XML.py
@@ -26,20 +26,19 @@
# Ian Romanick <idr@us.ibm.com>
from decimal import Decimal
-import libxml2
+import xml.etree.ElementTree as ET
import re, sys, string
+import os.path
import typeexpr
def parse_GL_API( file_name, factory = None ):
- doc = libxml2.readFile( file_name, None, libxml2.XML_PARSE_XINCLUDE + libxml2.XML_PARSE_NOBLANKS + libxml2.XML_PARSE_DTDVALID + libxml2.XML_PARSE_DTDATTR + libxml2.XML_PARSE_DTDLOAD + libxml2.XML_PARSE_NOENT )
- ret = doc.xincludeProcess()
if not factory:
factory = gl_item_factory()
- api = factory.create_item( "api", None, None )
- api.process_element( doc )
+ api = factory.create_api()
+ api.parse_file( file_name )
# After the XML has been processed, we need to go back and assign
# dispatch offsets to the functions that request that their offsets
@@ -51,12 +50,10 @@ def parse_GL_API( file_name, factory = None ):
func.offset = api.next_offset;
api.next_offset += 1
- doc.freeDoc()
-
return api
-def is_attr_true( element, name ):
+def is_attr_true( element, name, default = "false" ):
"""Read a name value from an element's attributes.
The value read from the attribute list must be either 'true' or
@@ -64,7 +61,7 @@ def is_attr_true( element, name ):
value is 'true', non-zero will be returned. An exception will be
raised for any other value."""
- value = element.nsProp( name, None )
+ value = element.get( name, default )
if value == "true":
return 1
elif value == "false":
@@ -254,8 +251,8 @@ class gl_print_base(object):
def real_function_name(element):
- name = element.nsProp( "name", None )
- alias = element.nsProp( "alias", None )
+ name = element.get( "name" )
+ alias = element.get( "alias" )
if alias:
return alias
@@ -324,21 +321,22 @@ def create_parameter_string(parameters, include_names):
class gl_item(object):
- def __init__(self, element, context):
+ def __init__(self, element, context, category):
self.context = context
- self.name = element.nsProp( "name", None )
- self.category = real_category_name( element.parent.nsProp( "name", None ) )
+ self.name = element.get( "name" )
+ self.category = real_category_name( category )
+
return
class gl_type( gl_item ):
- def __init__(self, element, context):
- gl_item.__init__(self, element, context)
- self.size = int( element.nsProp( "size", None ), 0 )
+ def __init__(self, element, context, category):
+ gl_item.__init__(self, element, context, category)
+ self.size = int( element.get( "size" ), 0 )
te = typeexpr.type_expression( None )
tn = typeexpr.type_node()
- tn.size = int( element.nsProp( "size", None ), 0 )
+ tn.size = int( element.get( "size" ), 0 )
tn.integer = not is_attr_true( element, "float" )
tn.unsigned = is_attr_true( element, "unsigned" )
tn.pointer = is_attr_true( element, "pointer" )
@@ -354,11 +352,11 @@ class gl_type( gl_item ):
class gl_enum( gl_item ):
- def __init__(self, element, context):
- gl_item.__init__(self, element, context)
- self.value = int( element.nsProp( "value", None ), 0 )
+ def __init__(self, element, context, category):
+ gl_item.__init__(self, element, context, category)
+ self.value = int( element.get( "value" ), 0 )
- temp = element.nsProp( "count", None )
+ temp = element.get( "count" )
if not temp or temp == "?":
self.default_count = -1
else:
@@ -404,12 +402,12 @@ class gl_enum( gl_item ):
class gl_parameter(object):
def __init__(self, element, context):
- self.name = element.nsProp( "name", None )
+ self.name = element.get( "name" )
- ts = element.nsProp( "type", None )
+ ts = element.get( "type" )
self.type_expr = typeexpr.type_expression( ts, context )
- temp = element.nsProp( "variable_param", None )
+ temp = element.get( "variable_param" )
if temp:
self.count_parameter_list = temp.split( ' ' )
else:
@@ -420,7 +418,7 @@ class gl_parameter(object):
# statement will throw an exception, and the except block will
# take over.
- c = element.nsProp( "count", None )
+ c = element.get( "count" )
try:
count = int(c)
self.count = count
@@ -430,7 +428,7 @@ class gl_parameter(object):
self.count = 0
self.counter = c
- self.count_scale = int(element.nsProp( "count_scale", None ))
+ self.count_scale = int(element.get( "count_scale", "1" ))
elements = (count * self.count_scale)
if elements == 1:
@@ -450,19 +448,19 @@ class gl_parameter(object):
# Pixel data has special parameters.
- self.width = element.nsProp('img_width', None)
- self.height = element.nsProp('img_height', None)
- self.depth = element.nsProp('img_depth', None)
- self.extent = element.nsProp('img_extent', None)
+ self.width = element.get('img_width')
+ self.height = element.get('img_height')
+ self.depth = element.get('img_depth')
+ self.extent = element.get('img_extent')
- self.img_xoff = element.nsProp('img_xoff', None)
- self.img_yoff = element.nsProp('img_yoff', None)
- self.img_zoff = element.nsProp('img_zoff', None)
- self.img_woff = element.nsProp('img_woff', None)
+ self.img_xoff = element.get('img_xoff')
+ self.img_yoff = element.get('img_yoff')
+ self.img_zoff = element.get('img_zoff')
+ self.img_woff = element.get('img_woff')
- self.img_format = element.nsProp('img_format', None)
- self.img_type = element.nsProp('img_type', None)
- self.img_target = element.nsProp('img_target', None)
+ self.img_format = element.get('img_format')
+ self.img_type = element.get('img_type')
+ self.img_target = element.get('img_target')
self.img_pad_dimensions = is_attr_true( element, 'img_pad_dimensions' )
self.img_null_flag = is_attr_true( element, 'img_null_flag' )
@@ -648,17 +646,17 @@ class gl_function( gl_item ):
def process_element(self, element):
- name = element.nsProp( "name", None )
- alias = element.nsProp( "alias", None )
+ name = element.get( "name" )
+ alias = element.get( "alias" )
- if is_attr_true(element, "static_dispatch"):
+ if is_attr_true(element, "static_dispatch", "true"):
self.static_entry_points.append(name)
self.entry_points.append( name )
self.entry_point_api_map[name] = {}
for api in ('es1', 'es2'):
- version_str = element.nsProp(api, None)
+ version_str = element.get(api, 'none')
assert version_str is not None
if version_str != 'none':
version_decimal = Decimal(version_str)
@@ -667,15 +665,15 @@ class gl_function( gl_item ):
version_decimal < self.api_map[api]:
self.api_map[api] = version_decimal
- exec_flavor = element.nsProp('exec', None)
+ exec_flavor = element.get('exec')
if exec_flavor:
self.exec_flavor = exec_flavor
- deprecated = element.nsProp('deprecated', None)
+ deprecated = element.get('deprecated', 'none')
if deprecated != 'none':
self.deprecated = Decimal(deprecated)
- if not is_attr_true(element, 'desktop'):
+ if not is_attr_true(element, 'desktop', 'true'):
self.desktop = False
if alias:
@@ -686,7 +684,7 @@ class gl_function( gl_item ):
# Only try to set the offset when a non-alias entry-point
# is being processed.
- offset = element.nsProp( "offset", None )
+ offset = element.get( "offset" )
if offset:
try:
o = int( offset )
@@ -712,16 +710,12 @@ class gl_function( gl_item ):
parameters = []
return_type = "void"
- child = element.children
- while child:
- if child.type == "element":
- if child.name == "return":
- return_type = child.nsProp( "type", None )
- elif child.name == "param":
- param = self.context.factory.create_item( "parameter", child, self.context)
- parameters.append( param )
-
- child = child.next
+ for child in element.getchildren():
+ if child.tag == "return":
+ return_type = child.get( "type", "void" )
+ elif child.tag == "param":
+ param = self.context.factory.create_parameter(child, self.context)
+ parameters.append( param )
if self.initialized:
@@ -746,7 +740,7 @@ class gl_function( gl_item ):
if param.is_image():
self.images.append( param )
- if element.children:
+ if element.getchildren():
self.initialized = 1
self.entry_point_parameters[name] = parameters
else:
@@ -848,19 +842,20 @@ class gl_function( gl_item ):
class gl_item_factory(object):
"""Factory to create objects derived from gl_item."""
- def create_item(self, item_name, element, context):
- if item_name == "function":
- return gl_function(element, context)
- if item_name == "type":
- return gl_type(element, context)
- elif item_name == "enum":
- return gl_enum(element, context)
- elif item_name == "parameter":
- return gl_parameter(element, context)
- elif item_name == "api":
- return gl_api(self)
- else:
- return None
+ def create_function(self, element, context):
+ return gl_function(element, context)
+
+ def create_type(self, element, context, category):
+ return gl_type(element, context, category)
+
+ def create_enum(self, element, context, category):
+ return gl_enum(element, context, category)
+
+ def create_parameter(self, element, context):
+ return gl_parameter(element, context)
+
+ def create_api(self):
+ return gl_api(self)
class gl_api(object):
@@ -903,66 +898,64 @@ class gl_api(object):
self.functions_by_name = functions_by_name
- def process_element(self, doc):
- element = doc.children
- while element.type != "element" or element.name != "OpenGLAPI":
- element = element.next
- if element:
- self.process_OpenGLAPI(element)
- return
+ def parse_file(self, file_name):
+ doc = ET.parse( file_name )
+ self.process_element(file_name, doc)
- def process_OpenGLAPI(self, element):
- child = element.children
- while child:
- if child.type == "element":
- if child.name == "category":
- self.process_category( child )
- elif child.name == "OpenGLAPI":
- self.process_OpenGLAPI( child )
+ def process_element(self, file_name, doc):
+ element = doc.getroot()
+ if element.tag == "OpenGLAPI":
+ self.process_OpenGLAPI(file_name, element)
+ return
+
- child = child.next
+ def process_OpenGLAPI(self, file_name, element):
+ for child in element.getchildren():
+ if child.tag == "category":
+ self.process_category( child )
+ elif child.tag == "OpenGLAPI":
+ self.process_OpenGLAPI( file_name, child )
+ elif child.tag == '{http://www.w3.org/2001/XInclude}include':
+ href = child.get('href')
+ href = os.path.join(os.path.dirname(file_name), href)
+ self.parse_file(href)
return
def process_category(self, cat):
- cat_name = cat.nsProp( "name", None )
- cat_number = cat.nsProp( "number", None )
+ cat_name = cat.get( "name" )
+ cat_number = cat.get( "number" )
[cat_type, key] = classify_category(cat_name, cat_number)
self.categories[cat_type][key] = [cat_name, cat_number]
- child = cat.children
- while child:
- if child.type == "element":
- if child.name == "function":
- func_name = real_function_name( child )
-
- temp_name = child.nsProp( "name", None )
- self.category_dict[ temp_name ] = [cat_name, cat_number]
-
- if self.functions_by_name.has_key( func_name ):
- func = self.functions_by_name[ func_name ]
- func.process_element( child )
- else:
- func = self.factory.create_item( "function", child, self )
- self.functions_by_name[ func_name ] = func
+ for child in cat.getchildren():
+ if child.tag == "function":
+ func_name = real_function_name( child )
- if func.offset >= self.next_offset:
- self.next_offset = func.offset + 1
+ temp_name = child.get( "name" )
+ self.category_dict[ temp_name ] = [cat_name, cat_number]
+ if self.functions_by_name.has_key( func_name ):
+ func = self.functions_by_name[ func_name ]
+ func.process_element( child )
+ else:
+ func = self.factory.create_function( child, self )
+ self.functions_by_name[ func_name ] = func
- elif child.name == "enum":
- enum = self.factory.create_item( "enum", child, self )
- self.enums_by_name[ enum.name ] = enum
- elif child.name == "type":
- t = self.factory.create_item( "type", child, self )
- self.types_by_name[ "GL" + t.name ] = t
+ if func.offset >= self.next_offset:
+ self.next_offset = func.offset + 1
- child = child.next
+ elif child.tag == "enum":
+ enum = self.factory.create_enum( child, self, cat_name )
+ self.enums_by_name[ enum.name ] = enum
+ elif child.tag == "type":
+ t = self.factory.create_type( child, self, cat_name )
+ self.types_by_name[ "GL" + t.name ] = t
return
diff --git a/mesalib/src/mesa/drivers/common/meta.c b/mesalib/src/mesa/drivers/common/meta.c
index 76cbb41a9..acf927b09 100644
--- a/mesalib/src/mesa/drivers/common/meta.c
+++ b/mesalib/src/mesa/drivers/common/meta.c
@@ -53,6 +53,7 @@
#include "main/mipmap.h"
#include "main/multisample.h"
#include "main/objectlabel.h"
+#include "main/pipelineobj.h"
#include "main/pixel.h"
#include "main/pbo.h"
#include "main/polygon.h"
@@ -535,12 +536,20 @@ _mesa_meta_begin(struct gl_context *ctx, GLbitfield state)
_mesa_set_enable(ctx, GL_FRAGMENT_SHADER_ATI, GL_FALSE);
}
+ if (ctx->Extensions.ARB_separate_shader_objects) {
+ /* Warning it must be done before _mesa_UseProgram call */
+ _mesa_reference_pipeline_object(ctx, &save->_Shader, ctx->_Shader);
+ _mesa_reference_pipeline_object(ctx, &save->Pipeline,
+ ctx->Pipeline.Current);
+ _mesa_BindProgramPipeline(0);
+ }
+
for (i = 0; i < MESA_SHADER_STAGES; i++) {
_mesa_reference_shader_program(ctx, &save->Shader[i],
- ctx->Shader.CurrentProgram[i]);
+ ctx->_Shader->CurrentProgram[i]);
}
_mesa_reference_shader_program(ctx, &save->ActiveShader,
- ctx->Shader.ActiveProgram);
+ ctx->_Shader->ActiveProgram);
_mesa_UseProgram(0);
}
@@ -880,25 +889,37 @@ _mesa_meta_end(struct gl_context *ctx)
save->ATIFragmentShaderEnabled);
}
+ /* Warning it must be done before _mesa_use_shader_program call */
+ if (ctx->Extensions.ARB_separate_shader_objects) {
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, save->_Shader);
+ _mesa_reference_pipeline_object(ctx, &ctx->Pipeline.Current,
+ save->Pipeline);
+ _mesa_reference_pipeline_object(ctx, &save->Pipeline, NULL);
+ }
+
if (ctx->Extensions.ARB_vertex_shader) {
_mesa_use_shader_program(ctx, GL_VERTEX_SHADER,
- save->Shader[MESA_SHADER_VERTEX]);
+ save->Shader[MESA_SHADER_VERTEX],
+ ctx->_Shader);
}
if (_mesa_has_geometry_shaders(ctx))
_mesa_use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB,
- save->Shader[MESA_SHADER_GEOMETRY]);
+ save->Shader[MESA_SHADER_GEOMETRY],
+ ctx->_Shader);
if (ctx->Extensions.ARB_fragment_shader)
_mesa_use_shader_program(ctx, GL_FRAGMENT_SHADER,
- save->Shader[MESA_SHADER_FRAGMENT]);
+ save->Shader[MESA_SHADER_FRAGMENT],
+ ctx->_Shader);
- _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram,
+ _mesa_reference_shader_program(ctx, &ctx->_Shader->ActiveProgram,
save->ActiveShader);
for (i = 0; i < MESA_SHADER_STAGES; i++)
_mesa_reference_shader_program(ctx, &save->Shader[i], NULL);
_mesa_reference_shader_program(ctx, &save->ActiveShader, NULL);
+ _mesa_reference_pipeline_object(ctx, &save->_Shader, NULL);
}
if (state & MESA_META_STENCIL_TEST) {
diff --git a/mesalib/src/mesa/drivers/common/meta.h b/mesalib/src/mesa/drivers/common/meta.h
index e2ccb939e..4faae0b40 100644
--- a/mesalib/src/mesa/drivers/common/meta.h
+++ b/mesalib/src/mesa/drivers/common/meta.h
@@ -121,6 +121,8 @@ struct save_state
GLboolean ATIFragmentShaderEnabled;
struct gl_shader_program *Shader[MESA_SHADER_STAGES];
struct gl_shader_program *ActiveShader;
+ struct gl_pipeline_object *_Shader;
+ struct gl_pipeline_object *Pipeline;
/** MESA_META_STENCIL_TEST */
struct gl_stencil_attrib Stencil;
diff --git a/mesalib/src/mesa/main/api_validate.c b/mesalib/src/mesa/main/api_validate.c
index f3fd1a475..8f0b1998d 100644
--- a/mesalib/src/mesa/main/api_validate.c
+++ b/mesalib/src/mesa/main/api_validate.c
@@ -125,11 +125,14 @@ check_valid_to_render(struct gl_context *ctx, const char *function)
return GL_FALSE;
break;
- case API_OPENGL_COMPAT:
case API_OPENGL_CORE:
+ if (ctx->Array.VAO == ctx->Array.DefaultVAO)
+ return GL_FALSE;
+ /* fallthrough */
+ case API_OPENGL_COMPAT:
{
const struct gl_shader_program *vsProg =
- ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
+ ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX];
GLboolean haveVertexShader = (vsProg && vsProg->LinkStatus);
GLboolean haveVertexProgram = ctx->VertexProgram._Enabled;
if (haveVertexShader || haveVertexProgram) {
@@ -270,9 +273,9 @@ _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
* TRIANGLES_ADJACENCY_ARB or TRIANGLE_STRIP_ADJACENCY_ARB.
*
*/
- if (ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]) {
+ if (ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]) {
const GLenum geom_mode =
- ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]->Geom.InputType;
+ ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]->Geom.InputType;
switch (mode) {
case GL_POINTS:
valid_enum = (geom_mode == GL_POINTS);
@@ -331,8 +334,8 @@ _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
if (_mesa_is_xfb_active_and_unpaused(ctx)) {
GLboolean pass = GL_TRUE;
- if(ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]) {
- switch (ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]->Geom.OutputType) {
+ if(ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]) {
+ switch (ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY]->Geom.OutputType) {
case GL_POINTS:
pass = ctx->TransformFeedback.Mode == GL_POINTS;
break;
diff --git a/mesalib/src/mesa/main/context.c b/mesalib/src/mesa/main/context.c
index cd009c115..860ae8605 100644
--- a/mesalib/src/mesa/main/context.c
+++ b/mesalib/src/mesa/main/context.c
@@ -1841,6 +1841,7 @@ shader_linked_or_absent(struct gl_context *ctx,
* Prior to drawing anything with glBegin, glDrawArrays, etc. this function
* is called to see if it's valid to render. This involves checking that
* the current shader is valid and the framebuffer is complete.
+ * It also check the current pipeline object is valid if any.
* If an error is detected it'll be recorded here.
* \return GL_TRUE if OK to render, GL_FALSE if not
*/
@@ -1855,7 +1856,7 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
_mesa_update_state(ctx);
for (i = 0; i < MESA_SHADER_COMPUTE; i++) {
- if (!shader_linked_or_absent(ctx, ctx->Shader.CurrentProgram[i],
+ if (!shader_linked_or_absent(ctx, ctx->_Shader->CurrentProgram[i],
&from_glsl_shader[i], where))
return GL_FALSE;
}
@@ -1892,6 +1893,15 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
}
}
+ /* A pipeline object is bound */
+ if (ctx->_Shader->Name && !ctx->_Shader->Validated) {
+ /* Error message will be printed inside _mesa_validate_program_pipeline.
+ */
+ if (!_mesa_validate_program_pipeline(ctx, ctx->_Shader, GL_TRUE)) {
+ return GL_FALSE;
+ }
+ }
+
if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
_mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
"%s(incomplete framebuffer)", where);
@@ -1903,8 +1913,8 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
}
#ifdef DEBUG
- if (ctx->Shader.Flags & GLSL_LOG) {
- struct gl_shader_program **shProg = ctx->Shader.CurrentProgram;
+ if (ctx->_Shader->Flags & GLSL_LOG) {
+ struct gl_shader_program **shProg = ctx->_Shader->CurrentProgram;
gl_shader_stage i;
for (i = 0; i < MESA_SHADER_STAGES; i++) {
diff --git a/mesalib/src/mesa/main/fbobject.c b/mesalib/src/mesa/main/fbobject.c
index 107919f0b..6c4f1b548 100644
--- a/mesalib/src/mesa/main/fbobject.c
+++ b/mesalib/src/mesa/main/fbobject.c
@@ -632,7 +632,8 @@ _mesa_is_legal_color_format(const struct gl_context *ctx, GLenum baseFormat)
* Is the given base format a legal format for a color renderbuffer?
*/
static GLboolean
-is_format_color_renderable(const struct gl_context *ctx, mesa_format format, GLenum internalFormat)
+is_format_color_renderable(const struct gl_context *ctx, mesa_format format,
+ GLenum internalFormat)
{
const GLenum baseFormat =
_mesa_get_format_base_format(format);
@@ -664,7 +665,8 @@ is_format_color_renderable(const struct gl_context *ctx, mesa_format format, GLe
break;
}
- if (format == MESA_FORMAT_B10G10R10A2_UNORM && internalFormat != GL_RGB10_A2) {
+ if (format == MESA_FORMAT_B10G10R10A2_UNORM &&
+ internalFormat != GL_RGB10_A2) {
return GL_FALSE;
}
@@ -948,7 +950,8 @@ _mesa_test_framebuffer_completeness(struct gl_context *ctx,
attFormat = texImg->TexFormat;
numImages++;
- if (!is_format_color_renderable(ctx, attFormat, texImg->InternalFormat) &&
+ if (!is_format_color_renderable(ctx, attFormat,
+ texImg->InternalFormat) &&
!is_legal_depth_format(ctx, f)) {
fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT;
fbo_incomplete(ctx, "texture attachment incomplete", -1);
@@ -1071,7 +1074,9 @@ _mesa_test_framebuffer_completeness(struct gl_context *ctx,
return;
} else if (is_layered != att->Layered) {
fb->_Status = GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS;
- fbo_incomplete(ctx, "framebuffer attachment layer mode is inconsistent", i);
+ fbo_incomplete(ctx,
+ "framebuffer attachment layer mode is inconsistent",
+ i);
return;
} else if (att_layer_count > max_layer_count) {
max_layer_count = att_layer_count;
@@ -1149,7 +1154,8 @@ _mesa_IsRenderbuffer(GLuint renderbuffer)
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
if (renderbuffer) {
- struct gl_renderbuffer *rb = _mesa_lookup_renderbuffer(ctx, renderbuffer);
+ struct gl_renderbuffer *rb =
+ _mesa_lookup_renderbuffer(ctx, renderbuffer);
if (rb != NULL && rb != &DummyRenderbuffer)
return GL_TRUE;
}
@@ -1291,8 +1297,8 @@ _mesa_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
}
/* Section 4.4.2 (Attaching Images to Framebuffer Objects),
- * subsection "Attaching Renderbuffer Images to a Framebuffer," of
- * the OpenGL 3.1 spec says:
+ * subsection "Attaching Renderbuffer Images to a Framebuffer,"
+ * of the OpenGL 3.1 spec says:
*
* "If a renderbuffer object is deleted while its image is
* attached to one or more attachment points in the currently
@@ -1387,15 +1393,15 @@ _mesa_base_fbo_format(struct gl_context *ctx, GLenum internalFormat)
case GL_ALPHA8:
case GL_ALPHA12:
case GL_ALPHA16:
- return ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_framebuffer_object
- ? GL_ALPHA : 0;
+ return (ctx->API == API_OPENGL_COMPAT &&
+ ctx->Extensions.ARB_framebuffer_object) ? GL_ALPHA : 0;
case GL_LUMINANCE:
case GL_LUMINANCE4:
case GL_LUMINANCE8:
case GL_LUMINANCE12:
case GL_LUMINANCE16:
- return ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_framebuffer_object
- ? GL_LUMINANCE : 0;
+ return (ctx->API == API_OPENGL_COMPAT &&
+ ctx->Extensions.ARB_framebuffer_object) ? GL_LUMINANCE : 0;
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE4_ALPHA4:
case GL_LUMINANCE6_ALPHA2:
@@ -1403,15 +1409,15 @@ _mesa_base_fbo_format(struct gl_context *ctx, GLenum internalFormat)
case GL_LUMINANCE12_ALPHA4:
case GL_LUMINANCE12_ALPHA12:
case GL_LUMINANCE16_ALPHA16:
- return ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_framebuffer_object
- ? GL_LUMINANCE_ALPHA : 0;
+ return (ctx->API == API_OPENGL_COMPAT &&
+ ctx->Extensions.ARB_framebuffer_object) ? GL_LUMINANCE_ALPHA : 0;
case GL_INTENSITY:
case GL_INTENSITY4:
case GL_INTENSITY8:
case GL_INTENSITY12:
case GL_INTENSITY16:
- return ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_framebuffer_object
- ? GL_INTENSITY : 0;
+ return (ctx->API == API_OPENGL_COMPAT &&
+ ctx->Extensions.ARB_framebuffer_object) ? GL_INTENSITY : 0;
case GL_RGB8:
return GL_RGB;
case GL_RGB:
@@ -1458,11 +1464,13 @@ _mesa_base_fbo_format(struct gl_context *ctx, GLenum internalFormat)
return GL_DEPTH_STENCIL;
case GL_DEPTH_COMPONENT32F:
return ctx->Version >= 30
- || (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_depth_buffer_float)
+ || (ctx->API == API_OPENGL_COMPAT &&
+ ctx->Extensions.ARB_depth_buffer_float)
? GL_DEPTH_COMPONENT : 0;
case GL_DEPTH32F_STENCIL8:
return ctx->Version >= 30
- || (ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ARB_depth_buffer_float)
+ || (ctx->API == API_OPENGL_COMPAT &&
+ ctx->Extensions.ARB_depth_buffer_float)
? GL_DEPTH_STENCIL : 0;
case GL_RED:
case GL_R16:
@@ -1694,7 +1702,7 @@ invalidate_rb(GLuint key, void *data, void *userData)
/**
- * Helper function used by _mesa_RenderbufferStorage() and
+ * Helper function used by _mesa_RenderbufferStorage() and
* _mesa_RenderbufferStorageMultisample().
* samples will be NO_SAMPLES if called by _mesa_RenderbufferStorage().
*/
@@ -2142,6 +2150,7 @@ _mesa_BindFramebuffer(GLenum target, GLuint framebuffer)
bind_framebuffer(target, framebuffer, _mesa_is_gles(ctx));
}
+
void GLAPIENTRY
_mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)
{
@@ -2152,6 +2161,7 @@ _mesa_BindFramebufferEXT(GLenum target, GLuint framebuffer)
bind_framebuffer(target, framebuffer, true);
}
+
void GLAPIENTRY
_mesa_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
{
@@ -2222,7 +2232,6 @@ _mesa_GenFramebuffers(GLsizei n, GLuint *framebuffers)
}
-
GLenum GLAPIENTRY
_mesa_CheckFramebufferStatus(GLenum target)
{
@@ -2297,7 +2306,7 @@ reuse_framebuffer_texture_attachment(struct gl_framebuffer *fb,
* glFramebufferTexture(), false otherwise.
*/
static void
-framebuffer_texture(struct gl_context *ctx, const char *caller, GLenum target,
+framebuffer_texture(struct gl_context *ctx, const char *caller, GLenum target,
GLenum attachment, GLenum textarget, GLuint texture,
GLint level, GLint zoffset, GLboolean layered)
{
@@ -2492,10 +2501,9 @@ framebuffer_texture(struct gl_context *ctx, const char *caller, GLenum target,
}
-
void GLAPIENTRY
_mesa_FramebufferTexture1D(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level)
+ GLenum textarget, GLuint texture, GLint level)
{
GET_CURRENT_CONTEXT(ctx);
@@ -2528,7 +2536,7 @@ _mesa_FramebufferTexture1D(GLenum target, GLenum attachment,
void GLAPIENTRY
_mesa_FramebufferTexture2D(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture, GLint level)
+ GLenum textarget, GLuint texture, GLint level)
{
GET_CURRENT_CONTEXT(ctx);
@@ -2579,8 +2587,8 @@ _mesa_FramebufferTexture2D(GLenum target, GLenum attachment,
void GLAPIENTRY
_mesa_FramebufferTexture3D(GLenum target, GLenum attachment,
- GLenum textarget, GLuint texture,
- GLint level, GLint zoffset)
+ GLenum textarget, GLuint texture,
+ GLint level, GLint zoffset)
{
GET_CURRENT_CONTEXT(ctx);
@@ -2597,7 +2605,7 @@ _mesa_FramebufferTexture3D(GLenum target, GLenum attachment,
void GLAPIENTRY
_mesa_FramebufferTextureLayer(GLenum target, GLenum attachment,
- GLuint texture, GLint level, GLint layer)
+ GLuint texture, GLint level, GLint layer)
{
GET_CURRENT_CONTEXT(ctx);
@@ -2624,8 +2632,8 @@ _mesa_FramebufferTexture(GLenum target, GLenum attachment,
void GLAPIENTRY
_mesa_FramebufferRenderbuffer(GLenum target, GLenum attachment,
- GLenum renderbufferTarget,
- GLuint renderbuffer)
+ GLenum renderbufferTarget,
+ GLuint renderbuffer)
{
struct gl_renderbuffer_attachment *att;
struct gl_framebuffer *fb;
@@ -2634,7 +2642,8 @@ _mesa_FramebufferRenderbuffer(GLenum target, GLenum attachment,
fb = get_framebuffer_target(ctx, target);
if (!fb) {
- _mesa_error(ctx, GL_INVALID_ENUM, "glFramebufferRenderbufferEXT(target)");
+ _mesa_error(ctx, GL_INVALID_ENUM,
+ "glFramebufferRenderbufferEXT(target)");
return;
}
@@ -2691,7 +2700,6 @@ _mesa_FramebufferRenderbuffer(GLenum target, GLenum attachment,
}
}
-
FLUSH_VERTICES(ctx, _NEW_BUFFERS);
assert(ctx->Driver.FramebufferRenderbuffer);
@@ -2706,7 +2714,7 @@ _mesa_FramebufferRenderbuffer(GLenum target, GLenum attachment,
void GLAPIENTRY
_mesa_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
- GLenum pname, GLint *params)
+ GLenum pname, GLint *params)
{
const struct gl_renderbuffer_attachment *att;
struct gl_framebuffer *buffer;
@@ -2734,7 +2742,8 @@ _mesa_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
* OES_framebuffer_object spec refers to the EXT_framebuffer_object
* spec.
*/
- if ((!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_framebuffer_object)
+ if ((!_mesa_is_desktop_gl(ctx) ||
+ !ctx->Extensions.ARB_framebuffer_object)
&& !_mesa_is_gles3(ctx)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glGetFramebufferAttachmentParameteriv(bound FBO = 0)");
@@ -2845,7 +2854,8 @@ _mesa_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
}
return;
case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
- if ((!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_framebuffer_object)
+ if ((!_mesa_is_desktop_gl(ctx) ||
+ !ctx->Extensions.ARB_framebuffer_object)
&& !_mesa_is_gles3(ctx)) {
goto invalid_pname_enum;
}
@@ -2855,7 +2865,8 @@ _mesa_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
}
else {
if (ctx->Extensions.EXT_framebuffer_sRGB) {
- *params = _mesa_get_format_color_encoding(att->Renderbuffer->Format);
+ *params =
+ _mesa_get_format_color_encoding(att->Renderbuffer->Format);
}
else {
/* According to ARB_framebuffer_sRGB, we should return LINEAR
@@ -2865,7 +2876,8 @@ _mesa_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
}
return;
case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
- if ((ctx->API != API_OPENGL_COMPAT || !ctx->Extensions.ARB_framebuffer_object)
+ if ((ctx->API != API_OPENGL_COMPAT ||
+ !ctx->Extensions.ARB_framebuffer_object)
&& ctx->API != API_OPENGL_CORE
&& !_mesa_is_gles3(ctx)) {
goto invalid_pname_enum;
@@ -2884,7 +2896,8 @@ _mesa_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
* attachment is DEPTH_STENCIL_ATTACHMENT the query will fail and
* generate an INVALID_OPERATION error.
*/
- if (_mesa_is_gles3(ctx) && attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+ if (_mesa_is_gles3(ctx) &&
+ attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glGetFramebufferAttachmentParameteriv(cannot query "
"GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE of "
@@ -2916,7 +2929,8 @@ _mesa_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment,
case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
- if ((!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_framebuffer_object)
+ if ((!_mesa_is_desktop_gl(ctx) ||
+ !ctx->Extensions.ARB_framebuffer_object)
&& !_mesa_is_gles3(ctx)) {
goto invalid_pname_enum;
}
@@ -3079,6 +3093,7 @@ invalid_enum:
return;
}
+
void GLAPIENTRY
_mesa_InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
const GLenum *attachments, GLint x, GLint y,
@@ -3089,6 +3104,7 @@ _mesa_InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
"glInvalidateSubFramebuffer");
}
+
void GLAPIENTRY
_mesa_InvalidateFramebuffer(GLenum target, GLsizei numAttachments,
const GLenum *attachments)
@@ -3106,10 +3122,12 @@ _mesa_InvalidateFramebuffer(GLenum target, GLsizei numAttachments,
* <MAX_VIEWPORT_DIMS[1]> respectively."
*/
invalidate_framebuffer_storage(target, numAttachments, attachments,
- 0, 0, MAX_VIEWPORT_WIDTH, MAX_VIEWPORT_HEIGHT,
+ 0, 0,
+ MAX_VIEWPORT_WIDTH, MAX_VIEWPORT_HEIGHT,
"glInvalidateFramebuffer");
}
+
void GLAPIENTRY
_mesa_DiscardFramebufferEXT(GLenum target, GLsizei numAttachments,
const GLenum *attachments)
diff --git a/mesalib/src/mesa/main/ff_fragment_shader.cpp b/mesalib/src/mesa/main/ff_fragment_shader.cpp
index cad67aa85..1d2ad604b 100644
--- a/mesalib/src/mesa/main/ff_fragment_shader.cpp
+++ b/mesalib/src/mesa/main/ff_fragment_shader.cpp
@@ -317,9 +317,9 @@ static GLbitfield get_fp_input_mask( struct gl_context *ctx )
{
/* _NEW_PROGRAM */
const GLboolean vertexShader =
- (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] &&
- ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->LinkStatus &&
- ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->_LinkedShaders[MESA_SHADER_VERTEX]);
+ (ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX] &&
+ ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX]->LinkStatus &&
+ ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX]->_LinkedShaders[MESA_SHADER_VERTEX]);
const GLboolean vertexProgram = ctx->VertexProgram._Enabled;
GLbitfield fp_inputs = 0x0;
@@ -383,7 +383,7 @@ static GLbitfield get_fp_input_mask( struct gl_context *ctx )
* validation (see additional comments in state.c).
*/
if (vertexShader)
- vprog = ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->_LinkedShaders[MESA_SHADER_VERTEX]->Program;
+ vprog = ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX]->_LinkedShaders[MESA_SHADER_VERTEX]->Program;
else
vprog = &ctx->VertexProgram.Current->Base;
diff --git a/mesalib/src/mesa/main/format_pack.c b/mesalib/src/mesa/main/format_pack.c
index 9fbd41746..e3cbfff7e 100644
--- a/mesalib/src/mesa/main/format_pack.c
+++ b/mesalib/src/mesa/main/format_pack.c
@@ -96,22 +96,22 @@ linear_ubyte_to_srgb_ubyte(GLubyte cl)
*/
static void
-pack_ubyte_RGBA8888(const GLubyte src[4], void *dst)
+pack_ubyte_A8B8G8R8_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
*d = PACK_COLOR_8888(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
}
static void
-pack_float_RGBA8888(const GLfloat src[4], void *dst)
+pack_float_A8B8G8R8_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_RGBA8888(v, dst);
+ pack_ubyte_A8B8G8R8_UNORM(v, dst);
}
static void
-pack_row_ubyte_RGBA8888(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_A8B8G8R8_UNORM(GLuint n, const GLubyte src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
@@ -122,14 +122,14 @@ pack_row_ubyte_RGBA8888(GLuint n, const GLubyte src[][4], void *dst)
}
static void
-pack_row_float_RGBA8888(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_A8B8G8R8_UNORM(GLuint n, const GLfloat src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
for (i = 0; i < n; i++) {
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
- pack_ubyte_RGBA8888(v, d + i);
+ pack_ubyte_A8B8G8R8_UNORM(v, d + i);
}
}
@@ -140,22 +140,22 @@ pack_row_float_RGBA8888(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_RGBA8888_REV(const GLubyte src[4], void *dst)
+pack_ubyte_R8G8B8A8_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
*d = PACK_COLOR_8888(src[ACOMP], src[BCOMP], src[GCOMP], src[RCOMP]);
}
static void
-pack_float_RGBA8888_REV(const GLfloat src[4], void *dst)
+pack_float_R8G8B8A8_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_RGBA8888_REV(v, dst);
+ pack_ubyte_R8G8B8A8_UNORM(v, dst);
}
static void
-pack_row_ubyte_RGBA8888_REV(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_R8G8B8A8_UNORM(GLuint n, const GLubyte src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
@@ -166,14 +166,14 @@ pack_row_ubyte_RGBA8888_REV(GLuint n, const GLubyte src[][4], void *dst)
}
static void
-pack_row_float_RGBA8888_REV(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_R8G8B8A8_UNORM(GLuint n, const GLfloat src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
for (i = 0; i < n; i++) {
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
- pack_ubyte_RGBA8888_REV(v, d + i);
+ pack_ubyte_R8G8B8A8_UNORM(v, d + i);
}
}
@@ -183,22 +183,22 @@ pack_row_float_RGBA8888_REV(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_ARGB8888(const GLubyte src[4], void *dst)
+pack_ubyte_B8G8R8A8_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
*d = PACK_COLOR_8888(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
}
static void
-pack_float_ARGB8888(const GLfloat src[4], void *dst)
+pack_float_B8G8R8A8_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_ARGB8888(v, dst);
+ pack_ubyte_B8G8R8A8_UNORM(v, dst);
}
static void
-pack_row_ubyte_ARGB8888(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_B8G8R8A8_UNORM(GLuint n, const GLubyte src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
@@ -209,14 +209,14 @@ pack_row_ubyte_ARGB8888(GLuint n, const GLubyte src[][4], void *dst)
}
static void
-pack_row_float_ARGB8888(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_B8G8R8A8_UNORM(GLuint n, const GLfloat src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
for (i = 0; i < n; i++) {
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
- pack_ubyte_ARGB8888(v, d + i);
+ pack_ubyte_B8G8R8A8_UNORM(v, d + i);
}
}
@@ -226,22 +226,22 @@ pack_row_float_ARGB8888(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_ARGB8888_REV(const GLubyte src[4], void *dst)
+pack_ubyte_A8R8G8B8_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
*d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
}
static void
-pack_float_ARGB8888_REV(const GLfloat src[4], void *dst)
+pack_float_A8R8G8B8_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_ARGB8888_REV(v, dst);
+ pack_ubyte_A8R8G8B8_UNORM(v, dst);
}
static void
-pack_row_ubyte_ARGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_A8R8G8B8_UNORM(GLuint n, const GLubyte src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
@@ -252,14 +252,14 @@ pack_row_ubyte_ARGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
}
static void
-pack_row_float_ARGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_A8R8G8B8_UNORM(GLuint n, const GLfloat src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
for (i = 0; i < n; i++) {
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
- pack_ubyte_ARGB8888_REV(v, d + i);
+ pack_ubyte_A8R8G8B8_UNORM(v, d + i);
}
}
@@ -269,22 +269,22 @@ pack_row_float_ARGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_XRGB8888(const GLubyte src[4], void *dst)
+pack_ubyte_B8G8R8X8_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
*d = PACK_COLOR_8888(0x0, src[RCOMP], src[GCOMP], src[BCOMP]);
}
static void
-pack_float_XRGB8888(const GLfloat src[4], void *dst)
+pack_float_B8G8R8X8_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_XRGB8888(v, dst);
+ pack_ubyte_B8G8R8X8_UNORM(v, dst);
}
static void
-pack_row_ubyte_XRGB8888(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_B8G8R8X8_UNORM(GLuint n, const GLubyte src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
@@ -294,14 +294,14 @@ pack_row_ubyte_XRGB8888(GLuint n, const GLubyte src[][4], void *dst)
}
static void
-pack_row_float_XRGB8888(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_B8G8R8X8_UNORM(GLuint n, const GLfloat src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
for (i = 0; i < n; i++) {
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
- pack_ubyte_XRGB8888(v, d + i);
+ pack_ubyte_B8G8R8X8_UNORM(v, d + i);
}
}
@@ -311,22 +311,22 @@ pack_row_float_XRGB8888(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_XRGB8888_REV(const GLubyte src[4], void *dst)
+pack_ubyte_X8R8G8B8_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
*d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], 0);
}
static void
-pack_float_XRGB8888_REV(const GLfloat src[4], void *dst)
+pack_float_X8R8G8B8_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_XRGB8888_REV(v, dst);
+ pack_ubyte_X8R8G8B8_UNORM(v, dst);
}
static void
-pack_row_ubyte_XRGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_X8R8G8B8_UNORM(GLuint n, const GLubyte src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
@@ -336,14 +336,14 @@ pack_row_ubyte_XRGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
}
static void
-pack_row_float_XRGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_X8R8G8B8_UNORM(GLuint n, const GLfloat src[][4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLuint i;
for (i = 0; i < n; i++) {
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
- pack_ubyte_XRGB8888_REV(v, d + i);
+ pack_ubyte_X8R8G8B8_UNORM(v, d + i);
}
}
@@ -353,7 +353,7 @@ pack_row_float_XRGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_RGB888(const GLubyte src[4], void *dst)
+pack_ubyte_BGR_UNORM8(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
d[2] = src[RCOMP];
@@ -362,7 +362,7 @@ pack_ubyte_RGB888(const GLubyte src[4], void *dst)
}
static void
-pack_float_RGB888(const GLfloat src[4], void *dst)
+pack_float_BGR_UNORM8(const GLfloat src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[RCOMP]);
@@ -371,7 +371,7 @@ pack_float_RGB888(const GLfloat src[4], void *dst)
}
static void
-pack_row_ubyte_RGB888(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_BGR_UNORM8(GLuint n, const GLubyte src[][4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
GLuint i;
@@ -383,7 +383,7 @@ pack_row_ubyte_RGB888(GLuint n, const GLubyte src[][4], void *dst)
}
static void
-pack_row_float_RGB888(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_BGR_UNORM8(GLuint n, const GLfloat src[][4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
GLuint i;
@@ -402,7 +402,7 @@ pack_row_float_RGB888(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_BGR888(const GLubyte src[4], void *dst)
+pack_ubyte_RGB_UNORM8(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
d[2] = src[BCOMP];
@@ -411,7 +411,7 @@ pack_ubyte_BGR888(const GLubyte src[4], void *dst)
}
static void
-pack_float_BGR888(const GLfloat src[4], void *dst)
+pack_float_RGB_UNORM8(const GLfloat src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[BCOMP]);
@@ -420,7 +420,7 @@ pack_float_BGR888(const GLfloat src[4], void *dst)
}
static void
-pack_row_ubyte_BGR888(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_RGB_UNORM8(GLuint n, const GLubyte src[][4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
GLuint i;
@@ -432,7 +432,7 @@ pack_row_ubyte_BGR888(GLuint n, const GLubyte src[][4], void *dst)
}
static void
-pack_row_float_BGR888(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_RGB_UNORM8(GLuint n, const GLfloat src[][4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
GLuint i;
@@ -451,41 +451,41 @@ pack_row_float_BGR888(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_RGB565(const GLubyte src[4], void *dst)
+pack_ubyte_B5G6R5_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = PACK_COLOR_565(src[RCOMP], src[GCOMP], src[BCOMP]);
}
static void
-pack_float_RGB565(const GLfloat src[4], void *dst)
+pack_float_B5G6R5_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[3];
UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
- pack_ubyte_RGB565(v, dst);
+ pack_ubyte_B5G6R5_UNORM(v, dst);
}
static void
-pack_row_ubyte_RGB565(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_B5G6R5_UNORM(GLuint n, const GLubyte src[][4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLuint i;
for (i = 0; i < n; i++) {
- pack_ubyte_RGB565(src[i], d + i);
+ pack_ubyte_B5G6R5_UNORM(src[i], d + i);
}
}
static void
-pack_row_float_RGB565(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_B5G6R5_UNORM(GLuint n, const GLfloat src[][4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLuint i;
for (i = 0; i < n; i++) {
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
- pack_ubyte_RGB565(v, d + i);
+ pack_ubyte_B5G6R5_UNORM(v, d + i);
}
}
@@ -497,14 +497,14 @@ pack_row_float_RGB565(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_RGB565_REV(const GLubyte src[4], void *dst)
+pack_ubyte_R5G6B5_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = PACK_COLOR_565_REV(src[RCOMP], src[GCOMP], src[BCOMP]);
}
static void
-pack_float_RGB565_REV(const GLfloat src[4], void *dst)
+pack_float_R5G6B5_UNORM(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLubyte r, g, b;
@@ -515,24 +515,24 @@ pack_float_RGB565_REV(const GLfloat src[4], void *dst)
}
static void
-pack_row_ubyte_RGB565_REV(GLuint n, const GLubyte src[][4], void *dst)
+pack_row_ubyte_R5G6B5_UNORM(GLuint n, const GLubyte src[][4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLuint i;
for (i = 0; i < n; i++) {
- pack_ubyte_RGB565_REV(src[i], d + i);
+ pack_ubyte_R5G6B5_UNORM(src[i], d + i);
}
}
static void
-pack_row_float_RGB565_REV(GLuint n, const GLfloat src[][4], void *dst)
+pack_row_float_R5G6B5_UNORM(GLuint n, const GLfloat src[][4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLuint i;
for (i = 0; i < n; i++) {
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
- pack_ubyte_RGB565_REV(v, d + i);
+ pack_ubyte_R5G6B5_UNORM(v, d + i);
}
}
@@ -542,18 +542,18 @@ pack_row_float_RGB565_REV(GLuint n, const GLfloat src[][4], void *dst)
*/
static void
-pack_ubyte_ARGB4444(const GLubyte src[4], void *dst)
+pack_ubyte_B4G4R4A4_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = PACK_COLOR_4444(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
}
static void
-pack_float_ARGB4444(const GLfloat src[4], void *dst)
+pack_float_B4G4R4A4_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_ARGB4444(v, dst);
+ pack_ubyte_B4G4R4A4_UNORM(v, dst);
}
/* use fallback row packing functions */
@@ -564,18 +564,18 @@ pack_float_ARGB4444(const GLfloat src[4], void *dst)
*/
static void
-pack_ubyte_ARGB4444_REV(const GLubyte src[4], void *dst)
+pack_ubyte_A4R4G4B4_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = PACK_COLOR_4444(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
}
static void
-pack_float_ARGB4444_REV(const GLfloat src[4], void *dst)
+pack_float_A4R4G4B4_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_ARGB4444_REV(v, dst);
+ pack_ubyte_A4R4G4B4_UNORM(v, dst);
}
/* use fallback row packing functions */
@@ -586,18 +586,18 @@ pack_float_ARGB4444_REV(const GLfloat src[4], void *dst)
*/
static void
-pack_ubyte_RGBA5551(const GLubyte src[4], void *dst)
+pack_ubyte_A1B5G5R5_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = PACK_COLOR_5551(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
}
static void
-pack_float_RGBA5551(const GLfloat src[4], void *dst)
+pack_float_A1B5G5R5_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_RGBA5551(v, dst);
+ pack_ubyte_A1B5G5R5_UNORM(v, dst);
}
/* use fallback row packing functions */
@@ -608,18 +608,18 @@ pack_float_RGBA5551(const GLfloat src[4], void *dst)
*/
static void
-pack_ubyte_ARGB1555(const GLubyte src[4], void *dst)
+pack_ubyte_B5G5R5A1_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
}
static void
-pack_float_ARGB1555(const GLfloat src[4], void *dst)
+pack_float_B5G5R5A1_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_ARGB1555(v, dst);
+ pack_ubyte_B5G5R5A1_UNORM(v, dst);
}
@@ -629,7 +629,7 @@ pack_float_ARGB1555(const GLfloat src[4], void *dst)
*/
static void
-pack_ubyte_ARGB1555_REV(const GLubyte src[4], void *dst)
+pack_ubyte_A1R5G5B5_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst), tmp;
tmp = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
@@ -637,75 +637,75 @@ pack_ubyte_ARGB1555_REV(const GLubyte src[4], void *dst)
}
static void
-pack_float_ARGB1555_REV(const GLfloat src[4], void *dst)
+pack_float_A1R5G5B5_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
_mesa_unclamped_float_rgba_to_ubyte(v, src);
- pack_ubyte_ARGB1555_REV(v, dst);
+ pack_ubyte_A1R5G5B5_UNORM(v, dst);
}
/* MESA_FORMAT_L4A4_UNORM */
static void
-pack_ubyte_AL44(const GLubyte src[4], void *dst)
+pack_ubyte_L4A4_UNORM(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
*d = PACK_COLOR_44(src[ACOMP], src[RCOMP]);
}
static void
-pack_float_AL44(const GLfloat src[4], void *dst)
+pack_float_L4A4_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
- pack_ubyte_AL44(v, dst);
+ pack_ubyte_L4A4_UNORM(v, dst);
}
/* MESA_FORMAT_L8A8_UNORM */
static void
-pack_ubyte_AL88(const GLubyte src[4], void *dst)
+pack_ubyte_L8A8_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = PACK_COLOR_88(src[ACOMP], src[RCOMP]);
}
static void
-pack_float_AL88(const GLfloat src[4], void *dst)
+pack_float_L8A8_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
- pack_ubyte_AL88(v, dst);
+ pack_ubyte_L8A8_UNORM(v, dst);
}
/* MESA_FORMAT_A8L8_UNORM */
static void
-pack_ubyte_AL88_REV(const GLubyte src[4], void *dst)
+pack_ubyte_A8L8_UNORM(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = PACK_COLOR_88(src[RCOMP], src[ACOMP]);
}
static void
-pack_float_AL88_REV(const GLfloat src[4], void *dst)
+pack_float_A8L8_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
- pack_ubyte_AL88_REV(v, dst);
+ pack_ubyte_A8L8_UNORM(v, dst);
}
/* MESA_FORMAT_L16A16_UNORM */
static void
-pack_ubyte_AL1616(const GLubyte src[4], void *dst)
+pack_ubyte_L16A16_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
@@ -714,7 +714,7 @@ pack_ubyte_AL1616(const GLubyte src[4], void *dst)
}
static void
-pack_float_AL1616(const GLfloat src[4], void *dst)
+pack_float_L16A16_UNORM(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort l, a;
@@ -727,7 +727,7 @@ pack_float_AL1616(const GLfloat src[4], void *dst)
/* MESA_FORMAT_A16L16_UNORM */
static void
-pack_ubyte_AL1616_REV(const GLubyte src[4], void *dst)
+pack_ubyte_A16L16_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
@@ -736,7 +736,7 @@ pack_ubyte_AL1616_REV(const GLubyte src[4], void *dst)
}
static void
-pack_float_AL1616_REV(const GLfloat src[4], void *dst)
+pack_float_A16L16_UNORM(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort l, a;
@@ -749,34 +749,34 @@ pack_float_AL1616_REV(const GLfloat src[4], void *dst)
/* MESA_FORMAT_B2G3R3_UNORM */
static void
-pack_ubyte_RGB332(const GLubyte src[4], void *dst)
+pack_ubyte_B2G3R3_UNORM(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
*d = PACK_COLOR_332(src[RCOMP], src[GCOMP], src[BCOMP]);
}
static void
-pack_float_RGB332(const GLfloat src[4], void *dst)
+pack_float_B2G3R3_UNORM(const GLfloat src[4], void *dst)
{
GLubyte v[4];
UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
- pack_ubyte_RGB332(v, dst);
+ pack_ubyte_B2G3R3_UNORM(v, dst);
}
/* MESA_FORMAT_A_UNORM8 */
static void
-pack_ubyte_A8(const GLubyte src[4], void *dst)
+pack_ubyte_A_UNORM8(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
*d = src[ACOMP];
}
static void
-pack_float_A8(const GLfloat src[4], void *dst)
+pack_float_A_UNORM8(const GLfloat src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[ACOMP]);
@@ -786,14 +786,14 @@ pack_float_A8(const GLfloat src[4], void *dst)
/* MESA_FORMAT_A_UNORM16 */
static void
-pack_ubyte_A16(const GLubyte src[4], void *dst)
+pack_ubyte_A_UNORM16(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = UBYTE_TO_USHORT(src[ACOMP]);
}
static void
-pack_float_A16(const GLfloat src[4], void *dst)
+pack_float_A_UNORM16(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
UNCLAMPED_FLOAT_TO_USHORT(d[0], src[ACOMP]);
@@ -803,14 +803,14 @@ pack_float_A16(const GLfloat src[4], void *dst)
/* MESA_FORMAT_L_UNORM8 */
static void
-pack_ubyte_L8(const GLubyte src[4], void *dst)
+pack_ubyte_L_UNORM8(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
*d = src[RCOMP];
}
static void
-pack_float_L8(const GLfloat src[4], void *dst)
+pack_float_L_UNORM8(const GLfloat src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
@@ -820,14 +820,14 @@ pack_float_L8(const GLfloat src[4], void *dst)
/* MESA_FORMAT_L_UNORM16 */
static void
-pack_ubyte_L16(const GLubyte src[4], void *dst)
+pack_ubyte_L_UNORM16(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = UBYTE_TO_USHORT(src[RCOMP]);
}
static void
-pack_float_L16(const GLfloat src[4], void *dst)
+pack_float_L_UNORM16(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
@@ -867,14 +867,14 @@ pack_float_YCBCR_REV(const GLfloat src[4], void *dst)
/* MESA_FORMAT_R_UNORM8 */
static void
-pack_ubyte_R8(const GLubyte src[4], void *dst)
+pack_ubyte_R_UNORM8(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
*d = src[RCOMP];
}
static void
-pack_float_R8(const GLfloat src[4], void *dst)
+pack_float_R_UNORM8(const GLfloat src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
GLubyte r;
@@ -886,14 +886,14 @@ pack_float_R8(const GLfloat src[4], void *dst)
/* MESA_FORMAT_R8G8_UNORM */
static void
-pack_ubyte_GR88(const GLubyte src[4], void *dst)
+pack_ubyte_R8G8_UNORM(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
*d = PACK_COLOR_88(src[GCOMP], src[RCOMP]);
}
static void
-pack_float_GR88(const GLfloat src[4], void *dst)
+pack_float_R8G8_UNORM(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLubyte r, g;
@@ -906,14 +906,14 @@ pack_float_GR88(const GLfloat src[4], void *dst)
/* MESA_FORMAT_G8R8_UNORM */
static void
-pack_ubyte_RG88(const GLubyte src[4], void *dst)
+pack_ubyte_G8R8_UNORM(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
*d = PACK_COLOR_88(src[RCOMP], src[GCOMP]);
}
static void
-pack_float_RG88(const GLfloat src[4], void *dst)
+pack_float_G8R8_UNORM(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLubyte r, g;
@@ -926,14 +926,14 @@ pack_float_RG88(const GLfloat src[4], void *dst)
/* MESA_FORMAT_R_UNORM16 */
static void
-pack_ubyte_R16(const GLubyte src[4], void *dst)
+pack_ubyte_R_UNORM16(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = UBYTE_TO_USHORT(src[RCOMP]);
}
static void
-pack_float_R16(const GLfloat src[4], void *dst)
+pack_float_R_UNORM16(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
@@ -943,7 +943,7 @@ pack_float_R16(const GLfloat src[4], void *dst)
/* MESA_FORMAT_R16G16_UNORM */
static void
-pack_ubyte_GR1616(const GLubyte src[4], void *dst)
+pack_ubyte_R16G16_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
@@ -952,7 +952,7 @@ pack_ubyte_GR1616(const GLubyte src[4], void *dst)
}
static void
-pack_float_GR1616(const GLfloat src[4], void *dst)
+pack_float_R16G16_UNORM(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r, g;
@@ -965,7 +965,7 @@ pack_float_GR1616(const GLfloat src[4], void *dst)
/* MESA_FORMAT_G16R16_UNORM */
static void
-pack_ubyte_RG1616(const GLubyte src[4], void *dst)
+pack_ubyte_G16R16_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
@@ -975,7 +975,7 @@ pack_ubyte_RG1616(const GLubyte src[4], void *dst)
static void
-pack_float_RG1616(const GLfloat src[4], void *dst)
+pack_float_G16R16_UNORM(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r, g;
@@ -988,7 +988,7 @@ pack_float_RG1616(const GLfloat src[4], void *dst)
/* MESA_FORMAT_B10G10R10A2_UNORM */
static void
-pack_ubyte_ARGB2101010(const GLubyte src[4], void *dst)
+pack_ubyte_B10G10R10A2_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
@@ -999,7 +999,7 @@ pack_ubyte_ARGB2101010(const GLubyte src[4], void *dst)
}
static void
-pack_float_ARGB2101010(const GLfloat src[4], void *dst)
+pack_float_B10G10R10A2_UNORM(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r, g, b, a;
@@ -1014,7 +1014,7 @@ pack_float_ARGB2101010(const GLfloat src[4], void *dst)
/* MESA_FORMAT_R10G10B10A2_UINT */
static void
-pack_ubyte_ABGR2101010_UINT(const GLubyte src[4], void *dst)
+pack_ubyte_R10G10B10A2_UINT(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
@@ -1025,7 +1025,7 @@ pack_ubyte_ABGR2101010_UINT(const GLubyte src[4], void *dst)
}
static void
-pack_float_ABGR2101010_UINT(const GLfloat src[4], void *dst)
+pack_float_R10G10B10A2_UINT(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r, g, b, a;
@@ -1040,7 +1040,7 @@ pack_float_ABGR2101010_UINT(const GLfloat src[4], void *dst)
/* MESA_FORMAT_BGR_SRGB8 */
static void
-pack_ubyte_SRGB8(const GLubyte src[4], void *dst)
+pack_ubyte_BGR_SRGB8(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
d[2] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
@@ -1049,7 +1049,7 @@ pack_ubyte_SRGB8(const GLubyte src[4], void *dst)
}
static void
-pack_float_SRGB8(const GLfloat src[4], void *dst)
+pack_float_BGR_SRGB8(const GLfloat src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
d[2] = linear_float_to_srgb_ubyte(src[RCOMP]);
@@ -1061,7 +1061,7 @@ pack_float_SRGB8(const GLfloat src[4], void *dst)
/* MESA_FORMAT_A8B8G8R8_SRGB */
static void
-pack_ubyte_SRGBA8(const GLubyte src[4], void *dst)
+pack_ubyte_A8B8G8R8_SRGB(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
@@ -1071,7 +1071,7 @@ pack_ubyte_SRGBA8(const GLubyte src[4], void *dst)
}
static void
-pack_float_SRGBA8(const GLfloat src[4], void *dst)
+pack_float_A8B8G8R8_SRGB(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLubyte r, g, b, a;
@@ -1086,7 +1086,7 @@ pack_float_SRGBA8(const GLfloat src[4], void *dst)
/* MESA_FORMAT_B8G8R8A8_SRGB */
static void
-pack_ubyte_SARGB8(const GLubyte src[4], void *dst)
+pack_ubyte_B8G8R8A8_SRGB(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
@@ -1096,7 +1096,7 @@ pack_ubyte_SARGB8(const GLubyte src[4], void *dst)
}
static void
-pack_float_SARGB8(const GLfloat src[4], void *dst)
+pack_float_B8G8R8A8_SRGB(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLubyte r, g, b, a;
@@ -1111,7 +1111,7 @@ pack_float_SARGB8(const GLfloat src[4], void *dst)
/* MESA_FORMAT_R8G8B8A8_SRGB */
static void
-pack_ubyte_SABGR8(const GLubyte src[4], void *dst)
+pack_ubyte_R8G8B8A8_SRGB(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
@@ -1121,7 +1121,7 @@ pack_ubyte_SABGR8(const GLubyte src[4], void *dst)
}
static void
-pack_float_SABGR8(const GLfloat src[4], void *dst)
+pack_float_R8G8B8A8_SRGB(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLubyte r, g, b, a;
@@ -1136,14 +1136,14 @@ pack_float_SABGR8(const GLfloat src[4], void *dst)
/* MESA_FORMAT_L_SRGB8 */
static void
-pack_ubyte_SL8(const GLubyte src[4], void *dst)
+pack_ubyte_L_SRGB8(const GLubyte src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
*d = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
}
static void
-pack_float_SL8(const GLfloat src[4], void *dst)
+pack_float_L_SRGB8(const GLfloat src[4], void *dst)
{
GLubyte *d = ((GLubyte *) dst);
GLubyte l = linear_float_to_srgb_ubyte(src[RCOMP]);
@@ -1154,7 +1154,7 @@ pack_float_SL8(const GLfloat src[4], void *dst)
/* MESA_FORMAT_L8A8_SRGB */
static void
-pack_ubyte_SLA8(const GLubyte src[4], void *dst)
+pack_ubyte_L8A8_SRGB(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLubyte l = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
@@ -1162,7 +1162,7 @@ pack_ubyte_SLA8(const GLubyte src[4], void *dst)
}
static void
-pack_float_SLA8(const GLfloat src[4], void *dst)
+pack_float_L8A8_SRGB(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
GLubyte a, l = linear_float_to_srgb_ubyte(src[RCOMP]);
@@ -1262,14 +1262,14 @@ pack_float_RGB_FLOAT16(const GLfloat src[4], void *dst)
/* MESA_FORMAT_A_FLOAT32 */
static void
-pack_ubyte_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
+pack_ubyte_A_FLOAT32(const GLubyte src[4], void *dst)
{
GLfloat *d = ((GLfloat *) dst);
d[0] = UBYTE_TO_FLOAT(src[ACOMP]);
}
static void
-pack_float_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
+pack_float_A_FLOAT32(const GLfloat src[4], void *dst)
{
GLfloat *d = ((GLfloat *) dst);
d[0] = src[ACOMP];
@@ -1279,48 +1279,48 @@ pack_float_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
/* MESA_FORMAT_A_FLOAT16 */
static void
-pack_ubyte_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
+pack_ubyte_A_FLOAT16(const GLubyte src[4], void *dst)
{
GLhalfARB *d = ((GLhalfARB *) dst);
d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
}
static void
-pack_float_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
+pack_float_A_FLOAT16(const GLfloat src[4], void *dst)
{
GLhalfARB *d = ((GLhalfARB *) dst);
d[0] = _mesa_float_to_half(src[ACOMP]);
}
-/* MESA_FORMAT_L_FLOAT32 (and INTENSITY_FLOAT32, R_FLOAT32) */
+/* MESA_FORMAT_L_FLOAT32 (and I_FLOAT32, R_FLOAT32) */
static void
-pack_ubyte_LUMINANCE_FLOAT32(const GLubyte src[4], void *dst)
+pack_ubyte_L_FLOAT32(const GLubyte src[4], void *dst)
{
GLfloat *d = ((GLfloat *) dst);
d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
}
static void
-pack_float_LUMINANCE_FLOAT32(const GLfloat src[4], void *dst)
+pack_float_L_FLOAT32(const GLfloat src[4], void *dst)
{
GLfloat *d = ((GLfloat *) dst);
d[0] = src[RCOMP];
}
-/* MESA_FORMAT_L_FLOAT16 (and INTENSITY_FLOAT16, R_FLOAT32) */
+/* MESA_FORMAT_L_FLOAT16 (and I_FLOAT16, R_FLOAT32) */
static void
-pack_ubyte_LUMINANCE_FLOAT16(const GLubyte src[4], void *dst)
+pack_ubyte_L_FLOAT16(const GLubyte src[4], void *dst)
{
GLhalfARB *d = ((GLhalfARB *) dst);
d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
}
static void
-pack_float_LUMINANCE_FLOAT16(const GLfloat src[4], void *dst)
+pack_float_L_FLOAT16(const GLfloat src[4], void *dst)
{
GLhalfARB *d = ((GLhalfARB *) dst);
d[0] = _mesa_float_to_half(src[RCOMP]);
@@ -1330,7 +1330,7 @@ pack_float_LUMINANCE_FLOAT16(const GLfloat src[4], void *dst)
/* MESA_FORMAT_LA_FLOAT32 */
static void
-pack_ubyte_LUMINANCE_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
+pack_ubyte_LA_FLOAT32(const GLubyte src[4], void *dst)
{
GLfloat *d = ((GLfloat *) dst);
d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
@@ -1338,7 +1338,7 @@ pack_ubyte_LUMINANCE_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
}
static void
-pack_float_LUMINANCE_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
+pack_float_LA_FLOAT32(const GLfloat src[4], void *dst)
{
GLfloat *d = ((GLfloat *) dst);
d[0] = src[RCOMP];
@@ -1349,7 +1349,7 @@ pack_float_LUMINANCE_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
/* MESA_FORMAT_LA_FLOAT16 */
static void
-pack_ubyte_LUMINANCE_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
+pack_ubyte_LA_FLOAT16(const GLubyte src[4], void *dst)
{
GLhalfARB *d = ((GLhalfARB *) dst);
d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
@@ -1357,7 +1357,7 @@ pack_ubyte_LUMINANCE_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
}
static void
-pack_float_LUMINANCE_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
+pack_float_LA_FLOAT16(const GLfloat src[4], void *dst)
{
GLhalfARB *d = ((GLhalfARB *) dst);
d[0] = _mesa_float_to_half(src[RCOMP]);
@@ -1453,7 +1453,7 @@ pack_float_RGBA_16(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_R8(const GLfloat src[4], void *dst)
+pack_float_R_SNORM8(const GLfloat src[4], void *dst)
{
GLbyte *d = (GLbyte *) dst;
*d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1465,7 +1465,7 @@ pack_float_SIGNED_R8(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_RG88_REV(const GLfloat src[4], void *dst)
+pack_float_R8G8_SNORM(const GLfloat src[4], void *dst)
{
GLushort *d = (GLushort *) dst;
GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1479,7 +1479,7 @@ pack_float_SIGNED_RG88_REV(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_RGBX8888(const GLfloat src[4], void *dst)
+pack_float_X8B8G8R8_SNORM(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1495,7 +1495,7 @@ pack_float_SIGNED_RGBX8888(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_RGBA8888(const GLfloat src[4], void *dst)
+pack_float_A8B8G8R8_SNORM(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1511,7 +1511,7 @@ pack_float_SIGNED_RGBA8888(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_RGBA8888_REV(const GLfloat src[4], void *dst)
+pack_float_R8G8B8A8_SNORM(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1527,7 +1527,7 @@ pack_float_SIGNED_RGBA8888_REV(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_R16(const GLfloat src[4], void *dst)
+pack_float_R_SNORM16(const GLfloat src[4], void *dst)
{
GLshort *d = (GLshort *) dst;
*d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1539,7 +1539,7 @@ pack_float_SIGNED_R16(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_GR1616(const GLfloat src[4], void *dst)
+pack_float_R16G16_SNORM(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1553,7 +1553,7 @@ pack_float_SIGNED_GR1616(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_RGB_16(const GLfloat src[4], void *dst)
+pack_float_RGB_SNORM16(const GLfloat src[4], void *dst)
{
GLshort *d = (GLshort *) dst;
d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1567,7 +1567,7 @@ pack_float_SIGNED_RGB_16(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_RGBA_16(const GLfloat src[4], void *dst)
+pack_float_RGBA_SNORM16(const GLfloat src[4], void *dst)
{
GLshort *d = (GLshort *) dst;
d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1582,7 +1582,7 @@ pack_float_SIGNED_RGBA_16(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_A8(const GLfloat src[4], void *dst)
+pack_float_A_SNORM8(const GLfloat src[4], void *dst)
{
GLbyte *d = (GLbyte *) dst;
*d = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
@@ -1594,7 +1594,7 @@ pack_float_SIGNED_A8(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_L8(const GLfloat src[4], void *dst)
+pack_float_L_SNORM8(const GLfloat src[4], void *dst)
{
GLbyte *d = (GLbyte *) dst;
*d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1606,7 +1606,7 @@ pack_float_SIGNED_L8(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_AL88(const GLfloat src[4], void *dst)
+pack_float_L8A8_SNORM(const GLfloat src[4], void *dst)
{
GLushort *d = (GLushort *) dst;
GLbyte l = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1620,7 +1620,7 @@ pack_float_SIGNED_AL88(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_A16(const GLfloat src[4], void *dst)
+pack_float_A_SNORM16(const GLfloat src[4], void *dst)
{
GLshort *d = (GLshort *) dst;
*d = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
@@ -1632,7 +1632,7 @@ pack_float_SIGNED_A16(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_L16(const GLfloat src[4], void *dst)
+pack_float_L_SNORM16(const GLfloat src[4], void *dst)
{
GLshort *d = (GLshort *) dst;
*d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1644,7 +1644,7 @@ pack_float_SIGNED_L16(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_AL1616(const GLfloat src[4], void *dst)
+pack_float_LA_SNORM16(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLshort l = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1658,14 +1658,14 @@ pack_float_SIGNED_AL1616(const GLfloat src[4], void *dst)
*/
static void
-pack_float_RGB9_E5_FLOAT(const GLfloat src[4], void *dst)
+pack_float_R9G9B9E5_FLOAT(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
*d = float3_to_rgb9e5(src);
}
static void
-pack_ubyte_RGB9_E5_FLOAT(const GLubyte src[4], void *dst)
+pack_ubyte_R9G9B9E5_FLOAT(const GLubyte src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLfloat rgb[3];
@@ -1682,7 +1682,7 @@ pack_ubyte_RGB9_E5_FLOAT(const GLubyte src[4], void *dst)
*/
static void
-pack_ubyte_R11_G11_B10_FLOAT(const GLubyte src[4], void *dst)
+pack_ubyte_R11G11B10_FLOAT(const GLubyte src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLfloat rgb[3];
@@ -1693,7 +1693,7 @@ pack_ubyte_R11_G11_B10_FLOAT(const GLubyte src[4], void *dst)
}
static void
-pack_float_R11_G11_B10_FLOAT(const GLfloat src[4], void *dst)
+pack_float_R11G11B10_FLOAT(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
*d = float3_to_r11g11b10f(src);
@@ -1760,7 +1760,7 @@ pack_float_XBGR8888_SNORM(const GLfloat src[4], void *dst)
*/
static void
-pack_float_XBGR8888_SRGB(const GLfloat src[4], void *dst)
+pack_float_R8G8B8X8_SRGB(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
@@ -1773,7 +1773,7 @@ pack_float_XBGR8888_SRGB(const GLfloat src[4], void *dst)
/* MESA_FORMAT_B10G10R10X2_UNORM */
static void
-pack_ubyte_XRGB2101010_UNORM(const GLubyte src[4], void *dst)
+pack_ubyte_B10G10R10X2_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
@@ -1783,7 +1783,7 @@ pack_ubyte_XRGB2101010_UNORM(const GLubyte src[4], void *dst)
}
static void
-pack_float_XRGB2101010_UNORM(const GLfloat src[4], void *dst)
+pack_float_B10G10R10X2_UNORM(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r, g, b;
@@ -1797,7 +1797,7 @@ pack_float_XRGB2101010_UNORM(const GLfloat src[4], void *dst)
/* MESA_FORMAT_RGBX_UNORM16 */
static void
-pack_ubyte_XBGR16161616_UNORM(const GLubyte src[4], void *dst)
+pack_ubyte_RGBX_UNORM16(const GLubyte src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
d[0] = UBYTE_TO_USHORT(src[RCOMP]);
@@ -1807,7 +1807,7 @@ pack_ubyte_XBGR16161616_UNORM(const GLubyte src[4], void *dst)
}
static void
-pack_float_XBGR16161616_UNORM(const GLfloat src[4], void *dst)
+pack_float_RGBX_UNORM16(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
@@ -1820,7 +1820,7 @@ pack_float_XBGR16161616_UNORM(const GLfloat src[4], void *dst)
/* MESA_FORMAT_RGBX_SNORM16 */
static void
-pack_float_XBGR16161616_SNORM(const GLfloat src[4], void *dst)
+pack_float_RGBX_SNORM16(const GLfloat src[4], void *dst)
{
GLushort *d = ((GLushort *) dst);
UNCLAMPED_FLOAT_TO_SHORT(d[0], src[RCOMP]);
@@ -1845,7 +1845,7 @@ pack_float_XBGR16161616_FLOAT(const GLfloat src[4], void *dst)
/* MESA_FORMAT_RGBX_FLOAT32 */
static void
-pack_float_XBGR32323232_FLOAT(const GLfloat src[4], void *dst)
+pack_float_RGBX_FLOAT32(const GLfloat src[4], void *dst)
{
GLfloat *d = ((GLfloat *) dst);
d[0] = src[RCOMP];
@@ -1857,7 +1857,7 @@ pack_float_XBGR32323232_FLOAT(const GLfloat src[4], void *dst)
/* MESA_FORMAT_R10G10B10A2_UNORM */
static void
-pack_ubyte_ABGR2101010(const GLubyte src[4], void *dst)
+pack_ubyte_R10G10B10A2_UNORM(const GLubyte src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
@@ -1868,7 +1868,7 @@ pack_ubyte_ABGR2101010(const GLubyte src[4], void *dst)
}
static void
-pack_float_ABGR2101010(const GLfloat src[4], void *dst)
+pack_float_R10G10B10A2_UNORM(const GLfloat src[4], void *dst)
{
GLuint *d = ((GLuint *) dst);
GLushort r, g, b, a;
@@ -1884,7 +1884,7 @@ pack_float_ABGR2101010(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_RG88(const GLfloat src[4], void *dst)
+pack_float_G8R8_SNORM(const GLfloat src[4], void *dst)
{
GLushort *d = (GLushort *) dst;
GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1897,7 +1897,7 @@ pack_float_SIGNED_RG88(const GLfloat src[4], void *dst)
*/
static void
-pack_float_SIGNED_RG1616(const GLfloat src[4], void *dst)
+pack_float_G16R16_SNORM(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
@@ -1910,7 +1910,7 @@ pack_float_SIGNED_RG1616(const GLfloat src[4], void *dst)
*/
static void
-pack_float_XRGB8888_SRGB(const GLfloat src[4], void *dst)
+pack_float_B8G8R8X8_SRGB(const GLfloat src[4], void *dst)
{
GLuint *d = (GLuint *) dst;
GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
@@ -1933,45 +1933,45 @@ _mesa_get_pack_ubyte_rgba_function(mesa_format format)
table[MESA_FORMAT_NONE] = NULL;
- table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_ubyte_RGBA8888;
- table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_ubyte_RGBA8888_REV;
- table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_ubyte_ARGB8888;
- table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_ubyte_ARGB8888_REV;
- table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_ubyte_RGBA8888; /* reused */
- table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_ubyte_RGBA8888_REV; /* reused */
- table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_ubyte_XRGB8888;
- table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_ubyte_XRGB8888_REV;
- table[MESA_FORMAT_BGR_UNORM8] = pack_ubyte_RGB888;
- table[MESA_FORMAT_RGB_UNORM8] = pack_ubyte_BGR888;
- table[MESA_FORMAT_B5G6R5_UNORM] = pack_ubyte_RGB565;
- table[MESA_FORMAT_R5G6B5_UNORM] = pack_ubyte_RGB565_REV;
- table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_ubyte_ARGB4444;
- table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_ubyte_ARGB4444_REV;
- table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_ubyte_RGBA5551;
- table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_ubyte_ARGB1555;
- table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_ubyte_ARGB1555_REV;
- table[MESA_FORMAT_L4A4_UNORM] = pack_ubyte_AL44;
- table[MESA_FORMAT_L8A8_UNORM] = pack_ubyte_AL88;
- table[MESA_FORMAT_A8L8_UNORM] = pack_ubyte_AL88_REV;
- table[MESA_FORMAT_L16A16_UNORM] = pack_ubyte_AL1616;
- table[MESA_FORMAT_A16L16_UNORM] = pack_ubyte_AL1616_REV;
- table[MESA_FORMAT_B2G3R3_UNORM] = pack_ubyte_RGB332;
- table[MESA_FORMAT_A_UNORM8] = pack_ubyte_A8;
- table[MESA_FORMAT_A_UNORM16] = pack_ubyte_A16;
- table[MESA_FORMAT_L_UNORM8] = pack_ubyte_L8;
- table[MESA_FORMAT_L_UNORM16] = pack_ubyte_L16;
- table[MESA_FORMAT_I_UNORM8] = pack_ubyte_L8; /* reuse pack_ubyte_L8 */
- table[MESA_FORMAT_I_UNORM16] = pack_ubyte_L16; /* reuse pack_ubyte_L16 */
+ table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_ubyte_A8B8G8R8_UNORM;
+ table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_ubyte_R8G8B8A8_UNORM;
+ table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_ubyte_B8G8R8A8_UNORM;
+ table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_ubyte_A8R8G8B8_UNORM;
+ table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_ubyte_A8B8G8R8_UNORM; /* reused */
+ table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_ubyte_R8G8B8A8_UNORM; /* reused */
+ table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_ubyte_B8G8R8X8_UNORM;
+ table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_ubyte_X8R8G8B8_UNORM;
+ table[MESA_FORMAT_BGR_UNORM8] = pack_ubyte_BGR_UNORM8;
+ table[MESA_FORMAT_RGB_UNORM8] = pack_ubyte_RGB_UNORM8;
+ table[MESA_FORMAT_B5G6R5_UNORM] = pack_ubyte_B5G6R5_UNORM;
+ table[MESA_FORMAT_R5G6B5_UNORM] = pack_ubyte_R5G6B5_UNORM;
+ table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_ubyte_B4G4R4A4_UNORM;
+ table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_ubyte_A4R4G4B4_UNORM;
+ table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_ubyte_A1B5G5R5_UNORM;
+ table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_ubyte_B5G5R5A1_UNORM;
+ table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_ubyte_A1R5G5B5_UNORM;
+ table[MESA_FORMAT_L4A4_UNORM] = pack_ubyte_L4A4_UNORM;
+ table[MESA_FORMAT_L8A8_UNORM] = pack_ubyte_L8A8_UNORM;
+ table[MESA_FORMAT_A8L8_UNORM] = pack_ubyte_A8L8_UNORM;
+ table[MESA_FORMAT_L16A16_UNORM] = pack_ubyte_L16A16_UNORM;
+ table[MESA_FORMAT_A16L16_UNORM] = pack_ubyte_A16L16_UNORM;
+ table[MESA_FORMAT_B2G3R3_UNORM] = pack_ubyte_B2G3R3_UNORM;
+ table[MESA_FORMAT_A_UNORM8] = pack_ubyte_A_UNORM8;
+ table[MESA_FORMAT_A_UNORM16] = pack_ubyte_A_UNORM16;
+ table[MESA_FORMAT_L_UNORM8] = pack_ubyte_L_UNORM8;
+ table[MESA_FORMAT_L_UNORM16] = pack_ubyte_L_UNORM16;
+ table[MESA_FORMAT_I_UNORM8] = pack_ubyte_L_UNORM8; /* reuse pack_ubyte_L_UNORM8 */
+ table[MESA_FORMAT_I_UNORM16] = pack_ubyte_L_UNORM16; /* reuse pack_ubyte_L_UNORM16 */
table[MESA_FORMAT_YCBCR] = pack_ubyte_YCBCR;
table[MESA_FORMAT_YCBCR_REV] = pack_ubyte_YCBCR_REV;
- table[MESA_FORMAT_R_UNORM8] = pack_ubyte_R8;
- table[MESA_FORMAT_R8G8_UNORM] = pack_ubyte_GR88;
- table[MESA_FORMAT_G8R8_UNORM] = pack_ubyte_RG88;
- table[MESA_FORMAT_R_UNORM16] = pack_ubyte_R16;
- table[MESA_FORMAT_R16G16_UNORM] = pack_ubyte_GR1616;
- table[MESA_FORMAT_G16R16_UNORM] = pack_ubyte_RG1616;
- table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_ubyte_ARGB2101010;
- table[MESA_FORMAT_R10G10B10A2_UINT] = pack_ubyte_ABGR2101010_UINT;
+ table[MESA_FORMAT_R_UNORM8] = pack_ubyte_R_UNORM8;
+ table[MESA_FORMAT_R8G8_UNORM] = pack_ubyte_R8G8_UNORM;
+ table[MESA_FORMAT_G8R8_UNORM] = pack_ubyte_G8R8_UNORM;
+ table[MESA_FORMAT_R_UNORM16] = pack_ubyte_R_UNORM16;
+ table[MESA_FORMAT_R16G16_UNORM] = pack_ubyte_R16G16_UNORM;
+ table[MESA_FORMAT_G16R16_UNORM] = pack_ubyte_G16R16_UNORM;
+ table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_ubyte_B10G10R10A2_UNORM;
+ table[MESA_FORMAT_R10G10B10A2_UINT] = pack_ubyte_R10G10B10A2_UINT;
/* should never convert RGBA to these formats */
table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
@@ -1983,12 +1983,12 @@ _mesa_get_pack_ubyte_rgba_function(mesa_format format)
table[MESA_FORMAT_S_UINT8] = NULL;
/* sRGB */
- table[MESA_FORMAT_BGR_SRGB8] = pack_ubyte_SRGB8;
- table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_ubyte_SRGBA8;
- table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_ubyte_SARGB8;
- table[MESA_FORMAT_R8G8B8A8_SRGB] = pack_ubyte_SABGR8;
- table[MESA_FORMAT_L_SRGB8] = pack_ubyte_SL8;
- table[MESA_FORMAT_L8A8_SRGB] = pack_ubyte_SLA8;
+ table[MESA_FORMAT_BGR_SRGB8] = pack_ubyte_BGR_SRGB8;
+ table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_ubyte_A8B8G8R8_SRGB;
+ table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_ubyte_B8G8R8A8_SRGB;
+ table[MESA_FORMAT_R8G8B8A8_SRGB] = pack_ubyte_R8G8B8A8_SRGB;
+ table[MESA_FORMAT_L_SRGB8] = pack_ubyte_L_SRGB8;
+ table[MESA_FORMAT_L8A8_SRGB] = pack_ubyte_L8A8_SRGB;
/* n/a */
table[MESA_FORMAT_SRGB_DXT1] = NULL; /* pack_ubyte_SRGB_DXT1; */
table[MESA_FORMAT_SRGBA_DXT1] = NULL; /* pack_ubyte_SRGBA_DXT1; */
@@ -2006,16 +2006,16 @@ _mesa_get_pack_ubyte_rgba_function(mesa_format format)
table[MESA_FORMAT_RGBA_FLOAT16] = pack_ubyte_RGBA_FLOAT16;
table[MESA_FORMAT_RGB_FLOAT32] = pack_ubyte_RGB_FLOAT32;
table[MESA_FORMAT_RGB_FLOAT16] = pack_ubyte_RGB_FLOAT16;
- table[MESA_FORMAT_A_FLOAT32] = pack_ubyte_ALPHA_FLOAT32;
- table[MESA_FORMAT_A_FLOAT16] = pack_ubyte_ALPHA_FLOAT16;
- table[MESA_FORMAT_L_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
- table[MESA_FORMAT_L_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
- table[MESA_FORMAT_LA_FLOAT32] = pack_ubyte_LUMINANCE_ALPHA_FLOAT32;
- table[MESA_FORMAT_LA_FLOAT16] = pack_ubyte_LUMINANCE_ALPHA_FLOAT16;
- table[MESA_FORMAT_I_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
- table[MESA_FORMAT_I_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
- table[MESA_FORMAT_R_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
- table[MESA_FORMAT_R_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
+ table[MESA_FORMAT_A_FLOAT32] = pack_ubyte_A_FLOAT32;
+ table[MESA_FORMAT_A_FLOAT16] = pack_ubyte_A_FLOAT16;
+ table[MESA_FORMAT_L_FLOAT32] = pack_ubyte_L_FLOAT32;
+ table[MESA_FORMAT_L_FLOAT16] = pack_ubyte_L_FLOAT16;
+ table[MESA_FORMAT_LA_FLOAT32] = pack_ubyte_LA_FLOAT32;
+ table[MESA_FORMAT_LA_FLOAT16] = pack_ubyte_LA_FLOAT16;
+ table[MESA_FORMAT_I_FLOAT32] = pack_ubyte_L_FLOAT32;
+ table[MESA_FORMAT_I_FLOAT16] = pack_ubyte_L_FLOAT16;
+ table[MESA_FORMAT_R_FLOAT32] = pack_ubyte_L_FLOAT32;
+ table[MESA_FORMAT_R_FLOAT16] = pack_ubyte_L_FLOAT16;
table[MESA_FORMAT_RG_FLOAT32] = pack_ubyte_RG_FLOAT32;
table[MESA_FORMAT_RG_FLOAT16] = pack_ubyte_RG_FLOAT16;
@@ -2053,8 +2053,8 @@ _mesa_get_pack_ubyte_rgba_function(mesa_format format)
table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
- table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_ubyte_RGB9_E5_FLOAT;
- table[MESA_FORMAT_R11G11B10_FLOAT] = pack_ubyte_R11_G11_B10_FLOAT;
+ table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_ubyte_R9G9B9E5_FLOAT;
+ table[MESA_FORMAT_R11G11B10_FLOAT] = pack_ubyte_R11G11B10_FLOAT;
table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_ubyte_XRGB4444_UNORM;
table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_ubyte_XRGB1555_UNORM;
@@ -2062,8 +2062,8 @@ _mesa_get_pack_ubyte_rgba_function(mesa_format format)
table[MESA_FORMAT_R8G8B8X8_SRGB] = NULL;
table[MESA_FORMAT_RGBX_UINT8] = NULL;
table[MESA_FORMAT_RGBX_SINT8] = NULL;
- table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_ubyte_XRGB2101010_UNORM;
- table[MESA_FORMAT_RGBX_UNORM16] = pack_ubyte_XBGR16161616_UNORM;
+ table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_ubyte_B10G10R10X2_UNORM;
+ table[MESA_FORMAT_RGBX_UNORM16] = pack_ubyte_RGBX_UNORM16;
table[MESA_FORMAT_RGBX_SNORM16] = NULL;
table[MESA_FORMAT_RGBX_FLOAT16] = NULL;
table[MESA_FORMAT_RGBX_UINT16] = NULL;
@@ -2072,7 +2072,7 @@ _mesa_get_pack_ubyte_rgba_function(mesa_format format)
table[MESA_FORMAT_RGBX_UINT32] = NULL;
table[MESA_FORMAT_RGBX_SINT32] = NULL;
- table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_ubyte_ABGR2101010;
+ table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_ubyte_R10G10B10A2_UNORM;
table[MESA_FORMAT_B8G8R8X8_SRGB] = NULL;
@@ -2098,46 +2098,46 @@ _mesa_get_pack_float_rgba_function(mesa_format format)
table[MESA_FORMAT_NONE] = NULL;
- table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_float_RGBA8888;
- table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_float_RGBA8888_REV;
- table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_float_ARGB8888;
- table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_float_ARGB8888_REV;
- table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_float_RGBA8888; /* reused */
- table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_float_RGBA8888_REV; /* reused */
- table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_float_XRGB8888;
- table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_float_XRGB8888_REV;
- table[MESA_FORMAT_BGR_UNORM8] = pack_float_RGB888;
- table[MESA_FORMAT_RGB_UNORM8] = pack_float_BGR888;
- table[MESA_FORMAT_B5G6R5_UNORM] = pack_float_RGB565;
- table[MESA_FORMAT_R5G6B5_UNORM] = pack_float_RGB565_REV;
- table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_float_ARGB4444;
- table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_float_ARGB4444_REV;
- table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_float_RGBA5551;
- table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_float_ARGB1555;
- table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_float_ARGB1555_REV;
-
- table[MESA_FORMAT_L4A4_UNORM] = pack_float_AL44;
- table[MESA_FORMAT_L8A8_UNORM] = pack_float_AL88;
- table[MESA_FORMAT_A8L8_UNORM] = pack_float_AL88_REV;
- table[MESA_FORMAT_L16A16_UNORM] = pack_float_AL1616;
- table[MESA_FORMAT_A16L16_UNORM] = pack_float_AL1616_REV;
- table[MESA_FORMAT_B2G3R3_UNORM] = pack_float_RGB332;
- table[MESA_FORMAT_A_UNORM8] = pack_float_A8;
- table[MESA_FORMAT_A_UNORM16] = pack_float_A16;
- table[MESA_FORMAT_L_UNORM8] = pack_float_L8;
- table[MESA_FORMAT_L_UNORM16] = pack_float_L16;
- table[MESA_FORMAT_I_UNORM8] = pack_float_L8; /* reuse pack_float_L8 */
- table[MESA_FORMAT_I_UNORM16] = pack_float_L16; /* reuse pack_float_L16 */
+ table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_float_A8B8G8R8_UNORM;
+ table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_float_R8G8B8A8_UNORM;
+ table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_float_B8G8R8A8_UNORM;
+ table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_float_A8R8G8B8_UNORM;
+ table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_float_A8B8G8R8_UNORM; /* reused */
+ table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_float_R8G8B8A8_UNORM; /* reused */
+ table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_float_B8G8R8X8_UNORM;
+ table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_float_X8R8G8B8_UNORM;
+ table[MESA_FORMAT_BGR_UNORM8] = pack_float_BGR_UNORM8;
+ table[MESA_FORMAT_RGB_UNORM8] = pack_float_RGB_UNORM8;
+ table[MESA_FORMAT_B5G6R5_UNORM] = pack_float_B5G6R5_UNORM;
+ table[MESA_FORMAT_R5G6B5_UNORM] = pack_float_R5G6B5_UNORM;
+ table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_float_B4G4R4A4_UNORM;
+ table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_float_A4R4G4B4_UNORM;
+ table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_float_A1B5G5R5_UNORM;
+ table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_float_B5G5R5A1_UNORM;
+ table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_float_A1R5G5B5_UNORM;
+
+ table[MESA_FORMAT_L4A4_UNORM] = pack_float_L4A4_UNORM;
+ table[MESA_FORMAT_L8A8_UNORM] = pack_float_L8A8_UNORM;
+ table[MESA_FORMAT_A8L8_UNORM] = pack_float_A8L8_UNORM;
+ table[MESA_FORMAT_L16A16_UNORM] = pack_float_L16A16_UNORM;
+ table[MESA_FORMAT_A16L16_UNORM] = pack_float_A16L16_UNORM;
+ table[MESA_FORMAT_B2G3R3_UNORM] = pack_float_B2G3R3_UNORM;
+ table[MESA_FORMAT_A_UNORM8] = pack_float_A_UNORM8;
+ table[MESA_FORMAT_A_UNORM16] = pack_float_A_UNORM16;
+ table[MESA_FORMAT_L_UNORM8] = pack_float_L_UNORM8;
+ table[MESA_FORMAT_L_UNORM16] = pack_float_L_UNORM16;
+ table[MESA_FORMAT_I_UNORM8] = pack_float_L_UNORM8; /* reuse pack_float_L_UNORM8 */
+ table[MESA_FORMAT_I_UNORM16] = pack_float_L_UNORM16; /* reuse pack_float_L_UNORM16 */
table[MESA_FORMAT_YCBCR] = pack_float_YCBCR;
table[MESA_FORMAT_YCBCR_REV] = pack_float_YCBCR_REV;
- table[MESA_FORMAT_R_UNORM8] = pack_float_R8;
- table[MESA_FORMAT_R8G8_UNORM] = pack_float_GR88;
- table[MESA_FORMAT_G8R8_UNORM] = pack_float_RG88;
- table[MESA_FORMAT_R_UNORM16] = pack_float_R16;
- table[MESA_FORMAT_R16G16_UNORM] = pack_float_GR1616;
- table[MESA_FORMAT_G16R16_UNORM] = pack_float_RG1616;
- table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_float_ARGB2101010;
- table[MESA_FORMAT_R10G10B10A2_UINT] = pack_float_ABGR2101010_UINT;
+ table[MESA_FORMAT_R_UNORM8] = pack_float_R_UNORM8;
+ table[MESA_FORMAT_R8G8_UNORM] = pack_float_R8G8_UNORM;
+ table[MESA_FORMAT_G8R8_UNORM] = pack_float_G8R8_UNORM;
+ table[MESA_FORMAT_R_UNORM16] = pack_float_R_UNORM16;
+ table[MESA_FORMAT_R16G16_UNORM] = pack_float_R16G16_UNORM;
+ table[MESA_FORMAT_G16R16_UNORM] = pack_float_G16R16_UNORM;
+ table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_float_B10G10R10A2_UNORM;
+ table[MESA_FORMAT_R10G10B10A2_UINT] = pack_float_R10G10B10A2_UINT;
/* should never convert RGBA to these formats */
table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
@@ -2148,12 +2148,12 @@ _mesa_get_pack_float_rgba_function(mesa_format format)
table[MESA_FORMAT_Z_UNORM32] = NULL;
table[MESA_FORMAT_S_UINT8] = NULL;
- table[MESA_FORMAT_BGR_SRGB8] = pack_float_SRGB8;
- table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_float_SRGBA8;
- table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_float_SARGB8;
- table[MESA_FORMAT_R8G8B8A8_SRGB] = pack_float_SABGR8;
- table[MESA_FORMAT_L_SRGB8] = pack_float_SL8;
- table[MESA_FORMAT_L8A8_SRGB] = pack_float_SLA8;
+ table[MESA_FORMAT_BGR_SRGB8] = pack_float_BGR_SRGB8;
+ table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_float_A8B8G8R8_SRGB;
+ table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_float_B8G8R8A8_SRGB;
+ table[MESA_FORMAT_R8G8B8A8_SRGB] = pack_float_R8G8B8A8_SRGB;
+ table[MESA_FORMAT_L_SRGB8] = pack_float_L_SRGB8;
+ table[MESA_FORMAT_L8A8_SRGB] = pack_float_L8A8_SRGB;
/* n/a */
table[MESA_FORMAT_SRGB_DXT1] = NULL;
@@ -2172,17 +2172,17 @@ _mesa_get_pack_float_rgba_function(mesa_format format)
table[MESA_FORMAT_RGBA_FLOAT16] = pack_float_RGBA_FLOAT16;
table[MESA_FORMAT_RGB_FLOAT32] = pack_float_RGB_FLOAT32;
table[MESA_FORMAT_RGB_FLOAT16] = pack_float_RGB_FLOAT16;
- table[MESA_FORMAT_A_FLOAT32] = pack_float_ALPHA_FLOAT32;
- table[MESA_FORMAT_A_FLOAT16] = pack_float_ALPHA_FLOAT16;
- table[MESA_FORMAT_L_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
- table[MESA_FORMAT_L_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
- table[MESA_FORMAT_LA_FLOAT32] = pack_float_LUMINANCE_ALPHA_FLOAT32;
- table[MESA_FORMAT_LA_FLOAT16] = pack_float_LUMINANCE_ALPHA_FLOAT16;
-
- table[MESA_FORMAT_I_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
- table[MESA_FORMAT_I_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
- table[MESA_FORMAT_R_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
- table[MESA_FORMAT_R_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
+ table[MESA_FORMAT_A_FLOAT32] = pack_float_A_FLOAT32;
+ table[MESA_FORMAT_A_FLOAT16] = pack_float_A_FLOAT16;
+ table[MESA_FORMAT_L_FLOAT32] = pack_float_L_FLOAT32;
+ table[MESA_FORMAT_L_FLOAT16] = pack_float_L_FLOAT16;
+ table[MESA_FORMAT_LA_FLOAT32] = pack_float_LA_FLOAT32;
+ table[MESA_FORMAT_LA_FLOAT16] = pack_float_LA_FLOAT16;
+
+ table[MESA_FORMAT_I_FLOAT32] = pack_float_L_FLOAT32;
+ table[MESA_FORMAT_I_FLOAT16] = pack_float_L_FLOAT16;
+ table[MESA_FORMAT_R_FLOAT32] = pack_float_L_FLOAT32;
+ table[MESA_FORMAT_R_FLOAT16] = pack_float_L_FLOAT16;
table[MESA_FORMAT_RG_FLOAT32] = pack_float_RG_FLOAT32;
table[MESA_FORMAT_RG_FLOAT16] = pack_float_RG_FLOAT16;
@@ -2198,49 +2198,49 @@ _mesa_get_pack_float_rgba_function(mesa_format format)
table[MESA_FORMAT_RGBA_UNORM16] = pack_float_RGBA_16;
- table[MESA_FORMAT_R_SNORM8] = pack_float_SIGNED_R8;
- table[MESA_FORMAT_R8G8_SNORM] = pack_float_SIGNED_RG88_REV;
- table[MESA_FORMAT_X8B8G8R8_SNORM] = pack_float_SIGNED_RGBX8888;
- table[MESA_FORMAT_A8B8G8R8_SNORM] = pack_float_SIGNED_RGBA8888;
- table[MESA_FORMAT_R8G8B8A8_SNORM] = pack_float_SIGNED_RGBA8888_REV;
- table[MESA_FORMAT_R_SNORM16] = pack_float_SIGNED_R16;
- table[MESA_FORMAT_R16G16_SNORM] = pack_float_SIGNED_GR1616;
- table[MESA_FORMAT_RGB_SNORM16] = pack_float_SIGNED_RGB_16;
- table[MESA_FORMAT_RGBA_SNORM16] = pack_float_SIGNED_RGBA_16;
- table[MESA_FORMAT_A_SNORM8] = pack_float_SIGNED_A8;
- table[MESA_FORMAT_L_SNORM8] = pack_float_SIGNED_L8;
- table[MESA_FORMAT_L8A8_SNORM] = pack_float_SIGNED_AL88;
- table[MESA_FORMAT_I_SNORM8] = pack_float_SIGNED_L8; /* reused */
- table[MESA_FORMAT_A_SNORM16] = pack_float_SIGNED_A16;
- table[MESA_FORMAT_L_SNORM16] = pack_float_SIGNED_L16;
- table[MESA_FORMAT_LA_SNORM16] = pack_float_SIGNED_AL1616;
- table[MESA_FORMAT_I_SNORM16] = pack_float_SIGNED_L16; /* reused */
-
- table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_float_RGB9_E5_FLOAT;
- table[MESA_FORMAT_R11G11B10_FLOAT] = pack_float_R11_G11_B10_FLOAT;
+ table[MESA_FORMAT_R_SNORM8] = pack_float_R_SNORM8;
+ table[MESA_FORMAT_R8G8_SNORM] = pack_float_R8G8_SNORM;
+ table[MESA_FORMAT_X8B8G8R8_SNORM] = pack_float_X8B8G8R8_SNORM;
+ table[MESA_FORMAT_A8B8G8R8_SNORM] = pack_float_A8B8G8R8_SNORM;
+ table[MESA_FORMAT_R8G8B8A8_SNORM] = pack_float_R8G8B8A8_SNORM;
+ table[MESA_FORMAT_R_SNORM16] = pack_float_R_SNORM16;
+ table[MESA_FORMAT_R16G16_SNORM] = pack_float_R16G16_SNORM;
+ table[MESA_FORMAT_RGB_SNORM16] = pack_float_RGB_SNORM16;
+ table[MESA_FORMAT_RGBA_SNORM16] = pack_float_RGBA_SNORM16;
+ table[MESA_FORMAT_A_SNORM8] = pack_float_A_SNORM8;
+ table[MESA_FORMAT_L_SNORM8] = pack_float_L_SNORM8;
+ table[MESA_FORMAT_L8A8_SNORM] = pack_float_L8A8_SNORM;
+ table[MESA_FORMAT_I_SNORM8] = pack_float_L_SNORM8; /* reused */
+ table[MESA_FORMAT_A_SNORM16] = pack_float_A_SNORM16;
+ table[MESA_FORMAT_L_SNORM16] = pack_float_L_SNORM16;
+ table[MESA_FORMAT_LA_SNORM16] = pack_float_LA_SNORM16;
+ table[MESA_FORMAT_I_SNORM16] = pack_float_L_SNORM16; /* reused */
+
+ table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_float_R9G9B9E5_FLOAT;
+ table[MESA_FORMAT_R11G11B10_FLOAT] = pack_float_R11G11B10_FLOAT;
table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_float_XRGB4444_UNORM;
table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_float_XRGB1555_UNORM;
table[MESA_FORMAT_R8G8B8X8_SNORM] = pack_float_XBGR8888_SNORM;
- table[MESA_FORMAT_R8G8B8X8_SRGB] = pack_float_XBGR8888_SRGB;
+ table[MESA_FORMAT_R8G8B8X8_SRGB] = pack_float_R8G8B8X8_SRGB;
table[MESA_FORMAT_RGBX_UINT8] = NULL;
table[MESA_FORMAT_RGBX_SINT8] = NULL;
- table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_float_XRGB2101010_UNORM;
- table[MESA_FORMAT_RGBX_UNORM16] = pack_float_XBGR16161616_UNORM;
- table[MESA_FORMAT_RGBX_SNORM16] = pack_float_XBGR16161616_SNORM;
+ table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_float_B10G10R10X2_UNORM;
+ table[MESA_FORMAT_RGBX_UNORM16] = pack_float_RGBX_UNORM16;
+ table[MESA_FORMAT_RGBX_SNORM16] = pack_float_RGBX_SNORM16;
table[MESA_FORMAT_RGBX_FLOAT16] = pack_float_XBGR16161616_FLOAT;
table[MESA_FORMAT_RGBX_UINT16] = NULL;
table[MESA_FORMAT_RGBX_SINT16] = NULL;
- table[MESA_FORMAT_RGBX_FLOAT32] = pack_float_XBGR32323232_FLOAT;
+ table[MESA_FORMAT_RGBX_FLOAT32] = pack_float_RGBX_FLOAT32;
table[MESA_FORMAT_RGBX_UINT32] = NULL;
table[MESA_FORMAT_RGBX_SINT32] = NULL;
- table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_float_ABGR2101010;
+ table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_float_R10G10B10A2_UNORM;
- table[MESA_FORMAT_G8R8_SNORM] = pack_float_SIGNED_RG88;
- table[MESA_FORMAT_G16R16_SNORM] = pack_float_SIGNED_RG1616;
+ table[MESA_FORMAT_G8R8_SNORM] = pack_float_G8R8_SNORM;
+ table[MESA_FORMAT_G16R16_SNORM] = pack_float_G16R16_SNORM;
- table[MESA_FORMAT_B8G8R8X8_SRGB] = pack_float_XRGB8888_SRGB;
+ table[MESA_FORMAT_B8G8R8X8_SRGB] = pack_float_B8G8R8X8_SRGB;
initialized = GL_TRUE;
}
@@ -2262,18 +2262,18 @@ get_pack_float_rgba_row_function(mesa_format format)
*/
memset(table, 0, sizeof(table));
- table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_float_RGBA8888;
- table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_float_RGBA8888_REV;
- table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_float_ARGB8888;
- table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_float_ARGB8888_REV;
- table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_float_RGBA8888; /* reused */
- table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_float_RGBA8888_REV; /* reused */
- table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_float_XRGB8888;
- table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_float_XRGB8888_REV;
- table[MESA_FORMAT_BGR_UNORM8] = pack_row_float_RGB888;
- table[MESA_FORMAT_RGB_UNORM8] = pack_row_float_BGR888;
- table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_float_RGB565;
- table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_float_RGB565_REV;
+ table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_float_A8B8G8R8_UNORM;
+ table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_float_R8G8B8A8_UNORM;
+ table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_float_B8G8R8A8_UNORM;
+ table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_float_A8R8G8B8_UNORM;
+ table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_float_A8B8G8R8_UNORM; /* reused */
+ table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_float_R8G8B8A8_UNORM; /* reused */
+ table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_float_B8G8R8X8_UNORM;
+ table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_float_X8R8G8B8_UNORM;
+ table[MESA_FORMAT_BGR_UNORM8] = pack_row_float_BGR_UNORM8;
+ table[MESA_FORMAT_RGB_UNORM8] = pack_row_float_RGB_UNORM8;
+ table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_float_B5G6R5_UNORM;
+ table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_float_R5G6B5_UNORM;
initialized = GL_TRUE;
}
@@ -2295,18 +2295,18 @@ get_pack_ubyte_rgba_row_function(mesa_format format)
*/
memset(table, 0, sizeof(table));
- table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_ubyte_RGBA8888;
- table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_ubyte_RGBA8888_REV;
- table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_ubyte_ARGB8888;
- table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_ubyte_ARGB8888_REV;
- table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_ubyte_RGBA8888; /* reused */
- table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_ubyte_RGBA8888_REV; /* reused */
- table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_ubyte_XRGB8888;
- table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_ubyte_XRGB8888_REV;
- table[MESA_FORMAT_BGR_UNORM8] = pack_row_ubyte_RGB888;
- table[MESA_FORMAT_RGB_UNORM8] = pack_row_ubyte_BGR888;
- table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_ubyte_RGB565;
- table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_ubyte_RGB565_REV;
+ table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_ubyte_A8B8G8R8_UNORM;
+ table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_ubyte_R8G8B8A8_UNORM;
+ table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_ubyte_B8G8R8A8_UNORM;
+ table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_ubyte_A8R8G8B8_UNORM;
+ table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_ubyte_A8B8G8R8_UNORM; /* reused */
+ table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_ubyte_R8G8B8A8_UNORM; /* reused */
+ table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_ubyte_B8G8R8X8_UNORM;
+ table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_ubyte_X8R8G8B8_UNORM;
+ table[MESA_FORMAT_BGR_UNORM8] = pack_row_ubyte_BGR_UNORM8;
+ table[MESA_FORMAT_RGB_UNORM8] = pack_row_ubyte_RGB_UNORM8;
+ table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_ubyte_B5G6R5_UNORM;
+ table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_ubyte_R5G6B5_UNORM;
initialized = GL_TRUE;
}
@@ -2425,7 +2425,7 @@ _mesa_pack_ubyte_rgba_rect(mesa_format format, GLuint width, GLuint height,
**/
static void
-pack_float_z_Z24_S8(const GLfloat *src, void *dst)
+pack_float_S8_UINT_Z24_UNORM(const GLfloat *src, void *dst)
{
/* don't disturb the stencil values */
GLuint *d = ((GLuint *) dst);
@@ -2437,7 +2437,7 @@ pack_float_z_Z24_S8(const GLfloat *src, void *dst)
}
static void
-pack_float_z_S8_Z24(const GLfloat *src, void *dst)
+pack_float_Z24_UNORM_S8_UINT(const GLfloat *src, void *dst)
{
/* don't disturb the stencil values */
GLuint *d = ((GLuint *) dst);
@@ -2449,7 +2449,7 @@ pack_float_z_S8_Z24(const GLfloat *src, void *dst)
}
static void
-pack_float_z_Z16(const GLfloat *src, void *dst)
+pack_float_Z_UNORM16(const GLfloat *src, void *dst)
{
GLushort *d = ((GLushort *) dst);
const GLfloat scale = (GLfloat) 0xffff;
@@ -2457,7 +2457,7 @@ pack_float_z_Z16(const GLfloat *src, void *dst)
}
static void
-pack_float_z_Z32(const GLfloat *src, void *dst)
+pack_float_Z_UNORM32(const GLfloat *src, void *dst)
{
GLuint *d = ((GLuint *) dst);
const GLdouble scale = (GLdouble) 0xffffffff;
@@ -2465,7 +2465,7 @@ pack_float_z_Z32(const GLfloat *src, void *dst)
}
static void
-pack_float_z_Z32_FLOAT(const GLfloat *src, void *dst)
+pack_float_Z_FLOAT32(const GLfloat *src, void *dst)
{
GLfloat *d = (GLfloat *) dst;
*d = *src;
@@ -2477,17 +2477,17 @@ _mesa_get_pack_float_z_func(mesa_format format)
switch (format) {
case MESA_FORMAT_S8_UINT_Z24_UNORM:
case MESA_FORMAT_X8_UINT_Z24_UNORM:
- return pack_float_z_Z24_S8;
+ return pack_float_S8_UINT_Z24_UNORM;
case MESA_FORMAT_Z24_UNORM_S8_UINT:
case MESA_FORMAT_Z24_UNORM_X8_UINT:
- return pack_float_z_S8_Z24;
+ return pack_float_Z24_UNORM_S8_UINT;
case MESA_FORMAT_Z_UNORM16:
- return pack_float_z_Z16;
+ return pack_float_Z_UNORM16;
case MESA_FORMAT_Z_UNORM32:
- return pack_float_z_Z32;
+ return pack_float_Z_UNORM32;
case MESA_FORMAT_Z_FLOAT32:
case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
- return pack_float_z_Z32_FLOAT;
+ return pack_float_Z_FLOAT32;
default:
_mesa_problem(NULL,
"unexpected format in _mesa_get_pack_float_z_func()");
@@ -2503,7 +2503,7 @@ _mesa_get_pack_float_z_func(mesa_format format)
**/
static void
-pack_uint_z_Z24_S8(const GLuint *src, void *dst)
+pack_uint_S8_UINT_Z24_UNORM(const GLuint *src, void *dst)
{
/* don't disturb the stencil values */
GLuint *d = ((GLuint *) dst);
@@ -2513,7 +2513,7 @@ pack_uint_z_Z24_S8(const GLuint *src, void *dst)
}
static void
-pack_uint_z_S8_Z24(const GLuint *src, void *dst)
+pack_uint_Z24_UNORM_S8_UINT(const GLuint *src, void *dst)
{
/* don't disturb the stencil values */
GLuint *d = ((GLuint *) dst);
@@ -2523,21 +2523,21 @@ pack_uint_z_S8_Z24(const GLuint *src, void *dst)
}
static void
-pack_uint_z_Z16(const GLuint *src, void *dst)
+pack_uint_Z_UNORM16(const GLuint *src, void *dst)
{
GLushort *d = ((GLushort *) dst);
*d = *src >> 16;
}
static void
-pack_uint_z_Z32(const GLuint *src, void *dst)
+pack_uint_Z_UNORM32(const GLuint *src, void *dst)
{
GLuint *d = ((GLuint *) dst);
*d = *src;
}
static void
-pack_uint_z_Z32_FLOAT(const GLuint *src, void *dst)
+pack_uint_Z_FLOAT32(const GLuint *src, void *dst)
{
GLuint *d = ((GLuint *) dst);
const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
@@ -2547,7 +2547,7 @@ pack_uint_z_Z32_FLOAT(const GLuint *src, void *dst)
}
static void
-pack_uint_z_Z32_FLOAT_X24S8(const GLuint *src, void *dst)
+pack_uint_Z_FLOAT32_X24S8(const GLuint *src, void *dst)
{
GLfloat *d = ((GLfloat *) dst);
const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
@@ -2562,18 +2562,18 @@ _mesa_get_pack_uint_z_func(mesa_format format)
switch (format) {
case MESA_FORMAT_S8_UINT_Z24_UNORM:
case MESA_FORMAT_X8_UINT_Z24_UNORM:
- return pack_uint_z_Z24_S8;
+ return pack_uint_S8_UINT_Z24_UNORM;
case MESA_FORMAT_Z24_UNORM_S8_UINT:
case MESA_FORMAT_Z24_UNORM_X8_UINT:
- return pack_uint_z_S8_Z24;
+ return pack_uint_Z24_UNORM_S8_UINT;
case MESA_FORMAT_Z_UNORM16:
- return pack_uint_z_Z16;
+ return pack_uint_Z_UNORM16;
case MESA_FORMAT_Z_UNORM32:
- return pack_uint_z_Z32;
+ return pack_uint_Z_UNORM32;
case MESA_FORMAT_Z_FLOAT32:
- return pack_uint_z_Z32_FLOAT;
+ return pack_uint_Z_FLOAT32;
case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
- return pack_uint_z_Z32_FLOAT_X24S8;
+ return pack_uint_Z_FLOAT32_X24S8;
default:
_mesa_problem(NULL, "unexpected format in _mesa_get_pack_uint_z_func()");
return NULL;
diff --git a/mesalib/src/mesa/main/format_unpack.c b/mesalib/src/mesa/main/format_unpack.c
index f85c875e4..2ef2e31d6 100644
--- a/mesalib/src/mesa/main/format_unpack.c
+++ b/mesalib/src/mesa/main/format_unpack.c
@@ -89,7 +89,7 @@ typedef void (*unpack_rgba_func)(const void *src, GLfloat dst[][4], GLuint n);
static void
-unpack_RGBA8888(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A8B8G8R8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -102,7 +102,7 @@ unpack_RGBA8888(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RGBA8888_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R8G8B8A8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -115,7 +115,7 @@ unpack_RGBA8888_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ARGB8888(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B8G8R8A8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -128,7 +128,7 @@ unpack_ARGB8888(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ARGB8888_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A8R8G8B8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -167,7 +167,7 @@ unpack_RGBX8888_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_XRGB8888(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B8G8R8X8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -180,7 +180,7 @@ unpack_XRGB8888(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_XRGB8888_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_X8R8G8B8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -193,7 +193,7 @@ unpack_XRGB8888_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RGB888(const void *src, GLfloat dst[][4], GLuint n)
+unpack_BGR_UNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = (const GLubyte *) src;
GLuint i;
@@ -206,7 +206,7 @@ unpack_RGB888(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_BGR888(const void *src, GLfloat dst[][4], GLuint n)
+unpack_RGB_UNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = (const GLubyte *) src;
GLuint i;
@@ -219,7 +219,7 @@ unpack_BGR888(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RGB565(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B5G6R5_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -232,7 +232,7 @@ unpack_RGB565(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RGB565_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R5G6B5_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
/* Warning: this function does not match the current Mesa definition
* of MESA_FORMAT_R5G6B5_UNORM.
@@ -249,7 +249,7 @@ unpack_RGB565_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ARGB4444(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B4G4R4A4_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -262,7 +262,7 @@ unpack_ARGB4444(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ARGB4444_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A4R4G4B4_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -275,7 +275,7 @@ unpack_ARGB4444_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RGBA5551(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A1B5G5R5_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -288,7 +288,7 @@ unpack_RGBA5551(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ARGB1555(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B5G5R5A1_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -301,7 +301,7 @@ unpack_ARGB1555(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ARGB1555_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A1R5G5B5_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
/* Warning: this function does not match the current Mesa definition
* of MESA_FORMAT_A1R5G5B5_UNORM.
@@ -318,7 +318,7 @@ unpack_ARGB1555_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_AL44(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L4A4_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -331,7 +331,7 @@ unpack_AL44(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_AL88(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L8A8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -344,7 +344,7 @@ unpack_AL88(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_AL88_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A8L8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -357,7 +357,7 @@ unpack_AL88_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_AL1616(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L16A16_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -370,7 +370,7 @@ unpack_AL1616(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_AL1616_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A16L16_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -383,7 +383,7 @@ unpack_AL1616_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RGB332(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B2G3R3_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -397,7 +397,7 @@ unpack_RGB332(const void *src, GLfloat dst[][4], GLuint n)
static void
-unpack_A8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A_UNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -410,7 +410,7 @@ unpack_A8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_A16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A_UNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -423,7 +423,7 @@ unpack_A16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_L8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L_UNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -436,7 +436,7 @@ unpack_L8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_L16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L_UNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -449,7 +449,7 @@ unpack_L16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_I8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_I_UNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -462,7 +462,7 @@ unpack_I8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_I16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_I_UNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -525,7 +525,7 @@ unpack_YCBCR_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_R8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R_UNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -538,7 +538,7 @@ unpack_R8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_GR88(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R8G8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -551,7 +551,7 @@ unpack_GR88(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RG88(const void *src, GLfloat dst[][4], GLuint n)
+unpack_G8R8_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -564,7 +564,7 @@ unpack_RG88(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_R16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R_UNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -577,7 +577,7 @@ unpack_R16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_GR1616(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R16G16_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -590,7 +590,7 @@ unpack_GR1616(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RG1616(const void *src, GLfloat dst[][4], GLuint n)
+unpack_G16R16_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -603,7 +603,7 @@ unpack_RG1616(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ARGB2101010(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B10G10R10A2_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -617,7 +617,7 @@ unpack_ARGB2101010(const void *src, GLfloat dst[][4], GLuint n)
static void
-unpack_ARGB2101010_UINT(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B10G10R10A2_UINT(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = (const GLuint *) src;
GLuint i;
@@ -631,7 +631,7 @@ unpack_ARGB2101010_UINT(const void *src, GLfloat dst[][4], GLuint n)
static void
-unpack_ABGR2101010_UINT(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R10G10B10A2_UINT(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -717,20 +717,20 @@ unpack_Z32(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_Z32_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
+unpack_Z32_FLOAT_X24S8(const void *src, GLfloat dst[][4], GLuint n)
{
- const GLfloat *s = ((const GLfloat *) src);
+ const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
GLuint i;
for (i = 0; i < n; i++) {
dst[i][0] =
dst[i][1] =
- dst[i][2] = s[i * 2];
+ dst[i][2] = s[i].z;
dst[i][3] = 1.0F;
}
}
static void
-unpack_Z32_FLOAT_X24S8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_Z32_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
{
const GLfloat *s = ((const GLfloat *) src);
GLuint i;
@@ -758,7 +758,7 @@ unpack_S8(const void *src, GLfloat dst[][4], GLuint n)
static void
-unpack_SRGB8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_BGR_SRGB8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = (const GLubyte *) src;
GLuint i;
@@ -771,7 +771,7 @@ unpack_SRGB8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SRGBA8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A8B8G8R8_SRGB(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -784,7 +784,7 @@ unpack_SRGBA8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SARGB8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B8G8R8A8_SRGB(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -797,7 +797,7 @@ unpack_SARGB8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SABGR8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R8G8B8A8_SRGB(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -810,7 +810,7 @@ unpack_SABGR8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SL8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L_SRGB8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -823,7 +823,7 @@ unpack_SL8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SLA8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L8A8_SRGB(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = (const GLushort *) src;
GLuint i;
@@ -939,7 +939,7 @@ unpack_RGB_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ALPHA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
{
const GLfloat *s = (const GLfloat *) src;
GLuint i;
@@ -952,7 +952,7 @@ unpack_ALPHA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ALPHA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLhalfARB *s = (const GLhalfARB *) src;
GLuint i;
@@ -965,7 +965,7 @@ unpack_ALPHA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_LUMINANCE_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
{
const GLfloat *s = (const GLfloat *) src;
GLuint i;
@@ -978,7 +978,7 @@ unpack_LUMINANCE_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_LUMINANCE_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLhalfARB *s = (const GLhalfARB *) src;
GLuint i;
@@ -991,7 +991,7 @@ unpack_LUMINANCE_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_LUMINANCE_ALPHA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
+unpack_LA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
{
const GLfloat *s = (const GLfloat *) src;
GLuint i;
@@ -1004,7 +1004,7 @@ unpack_LUMINANCE_ALPHA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_LUMINANCE_ALPHA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_LA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLhalfARB *s = (const GLhalfARB *) src;
GLuint i;
@@ -1017,7 +1017,7 @@ unpack_LUMINANCE_ALPHA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_INTENSITY_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
+unpack_I_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
{
const GLfloat *s = (const GLfloat *) src;
GLuint i;
@@ -1030,7 +1030,7 @@ unpack_INTENSITY_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_INTENSITY_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_I_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLhalfARB *s = (const GLhalfARB *) src;
GLuint i;
@@ -1721,7 +1721,7 @@ unpack_DUDV8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_R8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R_SNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLbyte *s = ((const GLbyte *) src);
GLuint i;
@@ -1734,7 +1734,7 @@ unpack_SIGNED_R8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_RG88_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R8G8_SNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -1747,7 +1747,7 @@ unpack_SIGNED_RG88_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_RGBX8888(const void *src, GLfloat dst[][4], GLuint n)
+unpack_X8B8G8R8_SNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -1760,7 +1760,7 @@ unpack_SIGNED_RGBX8888(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_RGBA8888(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A8B8G8R8_SNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -1773,7 +1773,7 @@ unpack_SIGNED_RGBA8888(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_RGBA8888_REV(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R8G8B8A8_SNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -1786,7 +1786,7 @@ unpack_SIGNED_RGBA8888_REV(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_R16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R_SNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = ((const GLshort *) src);
GLuint i;
@@ -1799,7 +1799,7 @@ unpack_SIGNED_R16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_GR1616(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R16G16_SNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -1812,7 +1812,7 @@ unpack_SIGNED_GR1616(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_RGB_16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_RGB_SNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = (const GLshort *) src;
GLuint i;
@@ -1825,7 +1825,7 @@ unpack_SIGNED_RGB_16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_RGBA_16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_RGBA_SNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = (const GLshort *) src;
GLuint i;
@@ -1967,7 +1967,7 @@ unpack_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1(const void *src, GLfloat dst[][4],
}
static void
-unpack_SIGNED_A8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A_SNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLbyte *s = ((const GLbyte *) src);
GLuint i;
@@ -1980,7 +1980,7 @@ unpack_SIGNED_A8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_L8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L_SNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLbyte *s = ((const GLbyte *) src);
GLuint i;
@@ -1993,7 +1993,7 @@ unpack_SIGNED_L8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_AL88(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L8A8_SNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = ((const GLshort *) src);
GLuint i;
@@ -2006,7 +2006,7 @@ unpack_SIGNED_AL88(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_I8(const void *src, GLfloat dst[][4], GLuint n)
+unpack_I_SNORM8(const void *src, GLfloat dst[][4], GLuint n)
{
const GLbyte *s = ((const GLbyte *) src);
GLuint i;
@@ -2019,7 +2019,7 @@ unpack_SIGNED_I8(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_A16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_A_SNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = ((const GLshort *) src);
GLuint i;
@@ -2032,7 +2032,7 @@ unpack_SIGNED_A16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_L16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_L_SNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = ((const GLshort *) src);
GLuint i;
@@ -2045,7 +2045,7 @@ unpack_SIGNED_L16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_AL1616(const void *src, GLfloat dst[][4], GLuint n)
+unpack_LA_SNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = (const GLshort *) src;
GLuint i;
@@ -2058,7 +2058,7 @@ unpack_SIGNED_AL1616(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_I16(const void *src, GLfloat dst[][4], GLuint n)
+unpack_I_SNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = ((const GLshort *) src);
GLuint i;
@@ -2071,7 +2071,7 @@ unpack_SIGNED_I16(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_RGB9_E5_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R9G9B9E5_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = (const GLuint *) src;
GLuint i;
@@ -2082,7 +2082,7 @@ unpack_RGB9_E5_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_R11_G11_B10_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R11G11B10_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = (const GLuint *) src;
GLuint i;
@@ -2132,7 +2132,7 @@ unpack_XBGR8888_SNORM(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_XBGR8888_SRGB(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R8G8B8X8_SRGB(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2171,7 +2171,7 @@ unpack_XBGR8888_SINT(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_XRGB2101010_UNORM(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B10G10R10X2_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2184,7 +2184,7 @@ unpack_XRGB2101010_UNORM(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_XBGR16161616_UNORM(const void *src, GLfloat dst[][4], GLuint n)
+unpack_RGBX_UNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = (const GLushort *) src;
GLuint i;
@@ -2197,7 +2197,7 @@ unpack_XBGR16161616_UNORM(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_XBGR16161616_SNORM(const void *src, GLfloat dst[][4], GLuint n)
+unpack_RGBX_SNORM16(const void *src, GLfloat dst[][4], GLuint n)
{
const GLshort *s = (const GLshort *) src;
GLuint i;
@@ -2249,7 +2249,7 @@ unpack_XBGR16161616_SINT(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_XBGR32323232_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
+unpack_RGBX_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
{
const GLfloat *s = (const GLfloat *) src;
GLuint i;
@@ -2288,7 +2288,7 @@ unpack_XBGR32323232_SINT(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_ABGR2101010(const void *src, GLfloat dst[][4], GLuint n)
+unpack_R10G10B10A2_UNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2301,7 +2301,7 @@ unpack_ABGR2101010(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_RG88(const void *src, GLfloat dst[][4], GLuint n)
+unpack_G8R8_SNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2314,7 +2314,7 @@ unpack_SIGNED_RG88(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_SIGNED_RG1616(const void *src, GLfloat dst[][4], GLuint n)
+unpack_G16R16_SNORM(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2327,7 +2327,7 @@ unpack_SIGNED_RG1616(const void *src, GLfloat dst[][4], GLuint n)
}
static void
-unpack_XRGB8888_SRGB(const void *src, GLfloat dst[][4], GLuint n)
+unpack_B8G8R8X8_SRGB(const void *src, GLfloat dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2351,46 +2351,46 @@ get_unpack_rgba_function(mesa_format format)
if (!initialized) {
table[MESA_FORMAT_NONE] = NULL;
- table[MESA_FORMAT_A8B8G8R8_UNORM] = unpack_RGBA8888;
- table[MESA_FORMAT_R8G8B8A8_UNORM] = unpack_RGBA8888_REV;
- table[MESA_FORMAT_B8G8R8A8_UNORM] = unpack_ARGB8888;
- table[MESA_FORMAT_A8R8G8B8_UNORM] = unpack_ARGB8888_REV;
+ table[MESA_FORMAT_A8B8G8R8_UNORM] = unpack_A8B8G8R8_UNORM;
+ table[MESA_FORMAT_R8G8B8A8_UNORM] = unpack_R8G8B8A8_UNORM;
+ table[MESA_FORMAT_B8G8R8A8_UNORM] = unpack_B8G8R8A8_UNORM;
+ table[MESA_FORMAT_A8R8G8B8_UNORM] = unpack_A8R8G8B8_UNORM;
table[MESA_FORMAT_X8B8G8R8_UNORM] = unpack_RGBX8888;
table[MESA_FORMAT_R8G8B8X8_UNORM] = unpack_RGBX8888_REV;
- table[MESA_FORMAT_B8G8R8X8_UNORM] = unpack_XRGB8888;
- table[MESA_FORMAT_X8R8G8B8_UNORM] = unpack_XRGB8888_REV;
- table[MESA_FORMAT_BGR_UNORM8] = unpack_RGB888;
- table[MESA_FORMAT_RGB_UNORM8] = unpack_BGR888;
- table[MESA_FORMAT_B5G6R5_UNORM] = unpack_RGB565;
- table[MESA_FORMAT_R5G6B5_UNORM] = unpack_RGB565_REV;
- table[MESA_FORMAT_B4G4R4A4_UNORM] = unpack_ARGB4444;
- table[MESA_FORMAT_A4R4G4B4_UNORM] = unpack_ARGB4444_REV;
- table[MESA_FORMAT_A1B5G5R5_UNORM] = unpack_RGBA5551;
- table[MESA_FORMAT_B5G5R5A1_UNORM] = unpack_ARGB1555;
- table[MESA_FORMAT_A1R5G5B5_UNORM] = unpack_ARGB1555_REV;
- table[MESA_FORMAT_L4A4_UNORM] = unpack_AL44;
- table[MESA_FORMAT_L8A8_UNORM] = unpack_AL88;
- table[MESA_FORMAT_A8L8_UNORM] = unpack_AL88_REV;
- table[MESA_FORMAT_L16A16_UNORM] = unpack_AL1616;
- table[MESA_FORMAT_A16L16_UNORM] = unpack_AL1616_REV;
- table[MESA_FORMAT_B2G3R3_UNORM] = unpack_RGB332;
- table[MESA_FORMAT_A_UNORM8] = unpack_A8;
- table[MESA_FORMAT_A_UNORM16] = unpack_A16;
- table[MESA_FORMAT_L_UNORM8] = unpack_L8;
- table[MESA_FORMAT_L_UNORM16] = unpack_L16;
- table[MESA_FORMAT_I_UNORM8] = unpack_I8;
- table[MESA_FORMAT_I_UNORM16] = unpack_I16;
+ table[MESA_FORMAT_B8G8R8X8_UNORM] = unpack_B8G8R8X8_UNORM;
+ table[MESA_FORMAT_X8R8G8B8_UNORM] = unpack_X8R8G8B8_UNORM;
+ table[MESA_FORMAT_BGR_UNORM8] = unpack_BGR_UNORM8;
+ table[MESA_FORMAT_RGB_UNORM8] = unpack_RGB_UNORM8;
+ table[MESA_FORMAT_B5G6R5_UNORM] = unpack_B5G6R5_UNORM;
+ table[MESA_FORMAT_R5G6B5_UNORM] = unpack_R5G6B5_UNORM;
+ table[MESA_FORMAT_B4G4R4A4_UNORM] = unpack_B4G4R4A4_UNORM;
+ table[MESA_FORMAT_A4R4G4B4_UNORM] = unpack_A4R4G4B4_UNORM;
+ table[MESA_FORMAT_A1B5G5R5_UNORM] = unpack_A1B5G5R5_UNORM;
+ table[MESA_FORMAT_B5G5R5A1_UNORM] = unpack_B5G5R5A1_UNORM;
+ table[MESA_FORMAT_A1R5G5B5_UNORM] = unpack_A1R5G5B5_UNORM;
+ table[MESA_FORMAT_L4A4_UNORM] = unpack_L4A4_UNORM;
+ table[MESA_FORMAT_L8A8_UNORM] = unpack_L8A8_UNORM;
+ table[MESA_FORMAT_A8L8_UNORM] = unpack_A8L8_UNORM;
+ table[MESA_FORMAT_L16A16_UNORM] = unpack_L16A16_UNORM;
+ table[MESA_FORMAT_A16L16_UNORM] = unpack_A16L16_UNORM;
+ table[MESA_FORMAT_B2G3R3_UNORM] = unpack_B2G3R3_UNORM;
+ table[MESA_FORMAT_A_UNORM8] = unpack_A_UNORM8;
+ table[MESA_FORMAT_A_UNORM16] = unpack_A_UNORM16;
+ table[MESA_FORMAT_L_UNORM8] = unpack_L_UNORM8;
+ table[MESA_FORMAT_L_UNORM16] = unpack_L_UNORM16;
+ table[MESA_FORMAT_I_UNORM8] = unpack_I_UNORM8;
+ table[MESA_FORMAT_I_UNORM16] = unpack_I_UNORM16;
table[MESA_FORMAT_YCBCR] = unpack_YCBCR;
table[MESA_FORMAT_YCBCR_REV] = unpack_YCBCR_REV;
- table[MESA_FORMAT_R_UNORM8] = unpack_R8;
- table[MESA_FORMAT_R8G8_UNORM] = unpack_GR88;
- table[MESA_FORMAT_G8R8_UNORM] = unpack_RG88;
- table[MESA_FORMAT_R_UNORM16] = unpack_R16;
- table[MESA_FORMAT_R16G16_UNORM] = unpack_GR1616;
- table[MESA_FORMAT_G16R16_UNORM] = unpack_RG1616;
- table[MESA_FORMAT_B10G10R10A2_UNORM] = unpack_ARGB2101010;
- table[MESA_FORMAT_B10G10R10A2_UINT] = unpack_ARGB2101010_UINT;
- table[MESA_FORMAT_R10G10B10A2_UINT] = unpack_ABGR2101010_UINT;
+ table[MESA_FORMAT_R_UNORM8] = unpack_R_UNORM8;
+ table[MESA_FORMAT_R8G8_UNORM] = unpack_R8G8_UNORM;
+ table[MESA_FORMAT_G8R8_UNORM] = unpack_G8R8_UNORM;
+ table[MESA_FORMAT_R_UNORM16] = unpack_R_UNORM16;
+ table[MESA_FORMAT_R16G16_UNORM] = unpack_R16G16_UNORM;
+ table[MESA_FORMAT_G16R16_UNORM] = unpack_G16R16_UNORM;
+ table[MESA_FORMAT_B10G10R10A2_UNORM] = unpack_B10G10R10A2_UNORM;
+ table[MESA_FORMAT_B10G10R10A2_UINT] = unpack_B10G10R10A2_UINT;
+ table[MESA_FORMAT_R10G10B10A2_UINT] = unpack_R10G10B10A2_UINT;
table[MESA_FORMAT_S8_UINT_Z24_UNORM] = unpack_Z24_S8;
table[MESA_FORMAT_Z24_UNORM_S8_UINT] = unpack_S8_Z24;
table[MESA_FORMAT_Z_UNORM16] = unpack_Z16;
@@ -2398,12 +2398,12 @@ get_unpack_rgba_function(mesa_format format)
table[MESA_FORMAT_X8_UINT_Z24_UNORM] = unpack_Z24_X8;
table[MESA_FORMAT_Z_UNORM32] = unpack_Z32;
table[MESA_FORMAT_S_UINT8] = unpack_S8;
- table[MESA_FORMAT_BGR_SRGB8] = unpack_SRGB8;
- table[MESA_FORMAT_A8B8G8R8_SRGB] = unpack_SRGBA8;
- table[MESA_FORMAT_B8G8R8A8_SRGB] = unpack_SARGB8;
- table[MESA_FORMAT_R8G8B8A8_SRGB] = unpack_SABGR8;
- table[MESA_FORMAT_L_SRGB8] = unpack_SL8;
- table[MESA_FORMAT_L8A8_SRGB] = unpack_SLA8;
+ table[MESA_FORMAT_BGR_SRGB8] = unpack_BGR_SRGB8;
+ table[MESA_FORMAT_A8B8G8R8_SRGB] = unpack_A8B8G8R8_SRGB;
+ table[MESA_FORMAT_B8G8R8A8_SRGB] = unpack_B8G8R8A8_SRGB;
+ table[MESA_FORMAT_R8G8B8A8_SRGB] = unpack_R8G8B8A8_SRGB;
+ table[MESA_FORMAT_L_SRGB8] = unpack_L_SRGB8;
+ table[MESA_FORMAT_L8A8_SRGB] = unpack_L8A8_SRGB;
table[MESA_FORMAT_SRGB_DXT1] = unpack_SRGB_DXT1;
table[MESA_FORMAT_SRGBA_DXT1] = unpack_SRGBA_DXT1;
table[MESA_FORMAT_SRGBA_DXT3] = unpack_SRGBA_DXT3;
@@ -2420,14 +2420,14 @@ get_unpack_rgba_function(mesa_format format)
table[MESA_FORMAT_RGBA_FLOAT16] = unpack_RGBA_FLOAT16;
table[MESA_FORMAT_RGB_FLOAT32] = unpack_RGB_FLOAT32;
table[MESA_FORMAT_RGB_FLOAT16] = unpack_RGB_FLOAT16;
- table[MESA_FORMAT_A_FLOAT32] = unpack_ALPHA_FLOAT32;
- table[MESA_FORMAT_A_FLOAT16] = unpack_ALPHA_FLOAT16;
- table[MESA_FORMAT_L_FLOAT32] = unpack_LUMINANCE_FLOAT32;
- table[MESA_FORMAT_L_FLOAT16] = unpack_LUMINANCE_FLOAT16;
- table[MESA_FORMAT_LA_FLOAT32] = unpack_LUMINANCE_ALPHA_FLOAT32;
- table[MESA_FORMAT_LA_FLOAT16] = unpack_LUMINANCE_ALPHA_FLOAT16;
- table[MESA_FORMAT_I_FLOAT32] = unpack_INTENSITY_FLOAT32;
- table[MESA_FORMAT_I_FLOAT16] = unpack_INTENSITY_FLOAT16;
+ table[MESA_FORMAT_A_FLOAT32] = unpack_A_FLOAT32;
+ table[MESA_FORMAT_A_FLOAT16] = unpack_A_FLOAT16;
+ table[MESA_FORMAT_L_FLOAT32] = unpack_L_FLOAT32;
+ table[MESA_FORMAT_L_FLOAT16] = unpack_L_FLOAT16;
+ table[MESA_FORMAT_LA_FLOAT32] = unpack_LA_FLOAT32;
+ table[MESA_FORMAT_LA_FLOAT16] = unpack_LA_FLOAT16;
+ table[MESA_FORMAT_I_FLOAT32] = unpack_I_FLOAT32;
+ table[MESA_FORMAT_I_FLOAT16] = unpack_I_FLOAT16;
table[MESA_FORMAT_R_FLOAT32] = unpack_R_FLOAT32;
table[MESA_FORMAT_R_FLOAT16] = unpack_R_FLOAT16;
table[MESA_FORMAT_RG_FLOAT32] = unpack_RG_FLOAT32;
@@ -2487,15 +2487,15 @@ get_unpack_rgba_function(mesa_format format)
table[MESA_FORMAT_RGBA_UINT32] = unpack_RGBA_UINT32;
table[MESA_FORMAT_DUDV8] = unpack_DUDV8;
- table[MESA_FORMAT_R_SNORM8] = unpack_SIGNED_R8;
- table[MESA_FORMAT_R8G8_SNORM] = unpack_SIGNED_RG88_REV;
- table[MESA_FORMAT_X8B8G8R8_SNORM] = unpack_SIGNED_RGBX8888;
- table[MESA_FORMAT_A8B8G8R8_SNORM] = unpack_SIGNED_RGBA8888;
- table[MESA_FORMAT_R8G8B8A8_SNORM] = unpack_SIGNED_RGBA8888_REV;
- table[MESA_FORMAT_R_SNORM16] = unpack_SIGNED_R16;
- table[MESA_FORMAT_R16G16_SNORM] = unpack_SIGNED_GR1616;
- table[MESA_FORMAT_RGB_SNORM16] = unpack_SIGNED_RGB_16;
- table[MESA_FORMAT_RGBA_SNORM16] = unpack_SIGNED_RGBA_16;
+ table[MESA_FORMAT_R_SNORM8] = unpack_R_SNORM8;
+ table[MESA_FORMAT_R8G8_SNORM] = unpack_R8G8_SNORM;
+ table[MESA_FORMAT_X8B8G8R8_SNORM] = unpack_X8B8G8R8_SNORM;
+ table[MESA_FORMAT_A8B8G8R8_SNORM] = unpack_A8B8G8R8_SNORM;
+ table[MESA_FORMAT_R8G8B8A8_SNORM] = unpack_R8G8B8A8_SNORM;
+ table[MESA_FORMAT_R_SNORM16] = unpack_R_SNORM16;
+ table[MESA_FORMAT_R16G16_SNORM] = unpack_R16G16_SNORM;
+ table[MESA_FORMAT_RGB_SNORM16] = unpack_RGB_SNORM16;
+ table[MESA_FORMAT_RGBA_SNORM16] = unpack_RGBA_SNORM16;
table[MESA_FORMAT_RGBA_UNORM16] = unpack_RGBA_16;
table[MESA_FORMAT_R_RGTC1_UNORM] = unpack_RED_RGTC1;
@@ -2521,17 +2521,17 @@ get_unpack_rgba_function(mesa_format format)
unpack_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
table[MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1] =
unpack_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1;
- table[MESA_FORMAT_A_SNORM8] = unpack_SIGNED_A8;
- table[MESA_FORMAT_L_SNORM8] = unpack_SIGNED_L8;
- table[MESA_FORMAT_L8A8_SNORM] = unpack_SIGNED_AL88;
- table[MESA_FORMAT_I_SNORM8] = unpack_SIGNED_I8;
- table[MESA_FORMAT_A_SNORM16] = unpack_SIGNED_A16;
- table[MESA_FORMAT_L_SNORM16] = unpack_SIGNED_L16;
- table[MESA_FORMAT_LA_SNORM16] = unpack_SIGNED_AL1616;
- table[MESA_FORMAT_I_SNORM16] = unpack_SIGNED_I16;
-
- table[MESA_FORMAT_R9G9B9E5_FLOAT] = unpack_RGB9_E5_FLOAT;
- table[MESA_FORMAT_R11G11B10_FLOAT] = unpack_R11_G11_B10_FLOAT;
+ table[MESA_FORMAT_A_SNORM8] = unpack_A_SNORM8;
+ table[MESA_FORMAT_L_SNORM8] = unpack_L_SNORM8;
+ table[MESA_FORMAT_L8A8_SNORM] = unpack_L8A8_SNORM;
+ table[MESA_FORMAT_I_SNORM8] = unpack_I_SNORM8;
+ table[MESA_FORMAT_A_SNORM16] = unpack_A_SNORM16;
+ table[MESA_FORMAT_L_SNORM16] = unpack_L_SNORM16;
+ table[MESA_FORMAT_LA_SNORM16] = unpack_LA_SNORM16;
+ table[MESA_FORMAT_I_SNORM16] = unpack_I_SNORM16;
+
+ table[MESA_FORMAT_R9G9B9E5_FLOAT] = unpack_R9G9B9E5_FLOAT;
+ table[MESA_FORMAT_R11G11B10_FLOAT] = unpack_R11G11B10_FLOAT;
table[MESA_FORMAT_Z_FLOAT32] = unpack_Z32_FLOAT;
table[MESA_FORMAT_Z32_FLOAT_S8X24_UINT] = unpack_Z32_FLOAT_X24S8;
@@ -2539,25 +2539,25 @@ get_unpack_rgba_function(mesa_format format)
table[MESA_FORMAT_B4G4R4X4_UNORM] = unpack_XRGB4444_UNORM;
table[MESA_FORMAT_B5G5R5X1_UNORM] = unpack_XRGB1555_UNORM;
table[MESA_FORMAT_R8G8B8X8_SNORM] = unpack_XBGR8888_SNORM;
- table[MESA_FORMAT_R8G8B8X8_SRGB] = unpack_XBGR8888_SRGB;
+ table[MESA_FORMAT_R8G8B8X8_SRGB] = unpack_R8G8B8X8_SRGB;
table[MESA_FORMAT_RGBX_UINT8] = unpack_XBGR8888_UINT;
table[MESA_FORMAT_RGBX_SINT8] = unpack_XBGR8888_SINT;
- table[MESA_FORMAT_B10G10R10X2_UNORM] = unpack_XRGB2101010_UNORM;
- table[MESA_FORMAT_RGBX_UNORM16] = unpack_XBGR16161616_UNORM;
- table[MESA_FORMAT_RGBX_SNORM16] = unpack_XBGR16161616_SNORM;
+ table[MESA_FORMAT_B10G10R10X2_UNORM] = unpack_B10G10R10X2_UNORM;
+ table[MESA_FORMAT_RGBX_UNORM16] = unpack_RGBX_UNORM16;
+ table[MESA_FORMAT_RGBX_SNORM16] = unpack_RGBX_SNORM16;
table[MESA_FORMAT_RGBX_FLOAT16] = unpack_XBGR16161616_FLOAT;
table[MESA_FORMAT_RGBX_UINT16] = unpack_XBGR16161616_UINT;
table[MESA_FORMAT_RGBX_SINT16] = unpack_XBGR16161616_SINT;
- table[MESA_FORMAT_RGBX_FLOAT32] = unpack_XBGR32323232_FLOAT;
+ table[MESA_FORMAT_RGBX_FLOAT32] = unpack_RGBX_FLOAT32;
table[MESA_FORMAT_RGBX_UINT32] = unpack_XBGR32323232_UINT;
table[MESA_FORMAT_RGBX_SINT32] = unpack_XBGR32323232_SINT;
- table[MESA_FORMAT_R10G10B10A2_UNORM] = unpack_ABGR2101010;
+ table[MESA_FORMAT_R10G10B10A2_UNORM] = unpack_R10G10B10A2_UNORM;
- table[MESA_FORMAT_G8R8_SNORM] = unpack_SIGNED_RG88;
- table[MESA_FORMAT_G16R16_SNORM] = unpack_SIGNED_RG1616;
+ table[MESA_FORMAT_G8R8_SNORM] = unpack_G8R8_SNORM;
+ table[MESA_FORMAT_G16R16_SNORM] = unpack_G16R16_SNORM;
- table[MESA_FORMAT_B8G8R8X8_SRGB] = unpack_XRGB8888_SRGB;
+ table[MESA_FORMAT_B8G8R8X8_SRGB] = unpack_B8G8R8X8_SRGB;
initialized = GL_TRUE;
}
@@ -2589,7 +2589,7 @@ _mesa_unpack_rgba_row(mesa_format format, GLuint n,
static void
-unpack_ubyte_RGBA8888(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_A8B8G8R8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2602,7 +2602,7 @@ unpack_ubyte_RGBA8888(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_RGBA8888_REV(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_R8G8B8A8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2615,7 +2615,7 @@ unpack_ubyte_RGBA8888_REV(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_ARGB8888(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_B8G8R8A8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2628,7 +2628,7 @@ unpack_ubyte_ARGB8888(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_ARGB8888_REV(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_A8R8G8B8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2667,7 +2667,7 @@ unpack_ubyte_RGBX8888_REV(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_XRGB8888(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_B8G8R8X8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2680,7 +2680,7 @@ unpack_ubyte_XRGB8888(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_XRGB8888_REV(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_X8R8G8B8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -2693,7 +2693,7 @@ unpack_ubyte_XRGB8888_REV(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_RGB888(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_BGR_UNORM8(const void *src, GLubyte dst[][4], GLuint n)
{
const GLubyte *s = (const GLubyte *) src;
GLuint i;
@@ -2706,7 +2706,7 @@ unpack_ubyte_RGB888(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_BGR888(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_RGB_UNORM8(const void *src, GLubyte dst[][4], GLuint n)
{
const GLubyte *s = (const GLubyte *) src;
GLuint i;
@@ -2719,7 +2719,7 @@ unpack_ubyte_BGR888(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_RGB565(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_B5G6R5_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2732,7 +2732,7 @@ unpack_ubyte_RGB565(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_RGB565_REV(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_R5G6B5_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
/* Warning: this function does not match the current Mesa definition
* of MESA_FORMAT_R5G6B5_UNORM.
@@ -2749,7 +2749,7 @@ unpack_ubyte_RGB565_REV(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_ARGB4444(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_B4G4R4A4_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2762,7 +2762,7 @@ unpack_ubyte_ARGB4444(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_ARGB4444_REV(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_A4R4G4B4_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2775,7 +2775,7 @@ unpack_ubyte_ARGB4444_REV(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_RGBA5551(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_A1B5G5R5_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2788,7 +2788,7 @@ unpack_ubyte_RGBA5551(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_ARGB1555(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_B5G5R5A1_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2801,7 +2801,7 @@ unpack_ubyte_ARGB1555(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_ARGB1555_REV(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_A1R5G5B5_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
/* Warning: this function does not match the current Mesa definition
* of MESA_FORMAT_A1R5G5B5_UNORM.
@@ -2818,7 +2818,7 @@ unpack_ubyte_ARGB1555_REV(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_AL44(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_L4A4_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -2831,7 +2831,7 @@ unpack_ubyte_AL44(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_AL88(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_L8A8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2844,7 +2844,7 @@ unpack_ubyte_AL88(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_AL88_REV(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_A8L8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2857,7 +2857,7 @@ unpack_ubyte_AL88_REV(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_RGB332(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_B2G3R3_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -2870,7 +2870,7 @@ unpack_ubyte_RGB332(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_A8(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_A_UNORM8(const void *src, GLubyte dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -2883,7 +2883,7 @@ unpack_ubyte_A8(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_L8(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_L_UNORM8(const void *src, GLubyte dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -2897,7 +2897,7 @@ unpack_ubyte_L8(const void *src, GLubyte dst[][4], GLuint n)
static void
-unpack_ubyte_I8(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_I_UNORM8(const void *src, GLubyte dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -2910,7 +2910,7 @@ unpack_ubyte_I8(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_R8(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_R_UNORM8(const void *src, GLubyte dst[][4], GLuint n)
{
const GLubyte *s = ((const GLubyte *) src);
GLuint i;
@@ -2923,7 +2923,7 @@ unpack_ubyte_R8(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_GR88(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_R8G8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2936,7 +2936,7 @@ unpack_ubyte_GR88(const void *src, GLubyte dst[][4], GLuint n)
}
static void
-unpack_ubyte_RG88(const void *src, GLubyte dst[][4], GLuint n)
+unpack_ubyte_G8R8_UNORM(const void *src, GLubyte dst[][4], GLuint n)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -2959,16 +2959,16 @@ _mesa_unpack_ubyte_rgba_row(mesa_format format, GLuint n,
{
switch (format) {
case MESA_FORMAT_A8B8G8R8_UNORM:
- unpack_ubyte_RGBA8888(src, dst, n);
+ unpack_ubyte_A8B8G8R8_UNORM(src, dst, n);
break;
case MESA_FORMAT_R8G8B8A8_UNORM:
- unpack_ubyte_RGBA8888_REV(src, dst, n);
+ unpack_ubyte_R8G8B8A8_UNORM(src, dst, n);
break;
case MESA_FORMAT_B8G8R8A8_UNORM:
- unpack_ubyte_ARGB8888(src, dst, n);
+ unpack_ubyte_B8G8R8A8_UNORM(src, dst, n);
break;
case MESA_FORMAT_A8R8G8B8_UNORM:
- unpack_ubyte_ARGB8888_REV(src, dst, n);
+ unpack_ubyte_A8R8G8B8_UNORM(src, dst, n);
break;
case MESA_FORMAT_X8B8G8R8_UNORM:
unpack_ubyte_RGBX8888(src, dst, n);
@@ -2977,67 +2977,67 @@ _mesa_unpack_ubyte_rgba_row(mesa_format format, GLuint n,
unpack_ubyte_RGBX8888_REV(src, dst, n);
break;
case MESA_FORMAT_B8G8R8X8_UNORM:
- unpack_ubyte_XRGB8888(src, dst, n);
+ unpack_ubyte_B8G8R8X8_UNORM(src, dst, n);
break;
case MESA_FORMAT_X8R8G8B8_UNORM:
- unpack_ubyte_XRGB8888_REV(src, dst, n);
+ unpack_ubyte_X8R8G8B8_UNORM(src, dst, n);
break;
case MESA_FORMAT_BGR_UNORM8:
- unpack_ubyte_RGB888(src, dst, n);
+ unpack_ubyte_BGR_UNORM8(src, dst, n);
break;
case MESA_FORMAT_RGB_UNORM8:
- unpack_ubyte_BGR888(src, dst, n);
+ unpack_ubyte_RGB_UNORM8(src, dst, n);
break;
case MESA_FORMAT_B5G6R5_UNORM:
- unpack_ubyte_RGB565(src, dst, n);
+ unpack_ubyte_B5G6R5_UNORM(src, dst, n);
break;
case MESA_FORMAT_R5G6B5_UNORM:
- unpack_ubyte_RGB565_REV(src, dst, n);
+ unpack_ubyte_R5G6B5_UNORM(src, dst, n);
break;
case MESA_FORMAT_B4G4R4A4_UNORM:
- unpack_ubyte_ARGB4444(src, dst, n);
+ unpack_ubyte_B4G4R4A4_UNORM(src, dst, n);
break;
case MESA_FORMAT_A4R4G4B4_UNORM:
- unpack_ubyte_ARGB4444_REV(src, dst, n);
+ unpack_ubyte_A4R4G4B4_UNORM(src, dst, n);
break;
case MESA_FORMAT_A1B5G5R5_UNORM:
- unpack_ubyte_RGBA5551(src, dst, n);
+ unpack_ubyte_A1B5G5R5_UNORM(src, dst, n);
break;
case MESA_FORMAT_B5G5R5A1_UNORM:
- unpack_ubyte_ARGB1555(src, dst, n);
+ unpack_ubyte_B5G5R5A1_UNORM(src, dst, n);
break;
case MESA_FORMAT_A1R5G5B5_UNORM:
- unpack_ubyte_ARGB1555_REV(src, dst, n);
+ unpack_ubyte_A1R5G5B5_UNORM(src, dst, n);
break;
case MESA_FORMAT_L4A4_UNORM:
- unpack_ubyte_AL44(src, dst, n);
+ unpack_ubyte_L4A4_UNORM(src, dst, n);
break;
case MESA_FORMAT_L8A8_UNORM:
- unpack_ubyte_AL88(src, dst, n);
+ unpack_ubyte_L8A8_UNORM(src, dst, n);
break;
case MESA_FORMAT_A8L8_UNORM:
- unpack_ubyte_AL88_REV(src, dst, n);
+ unpack_ubyte_A8L8_UNORM(src, dst, n);
break;
case MESA_FORMAT_B2G3R3_UNORM:
- unpack_ubyte_RGB332(src, dst, n);
+ unpack_ubyte_B2G3R3_UNORM(src, dst, n);
break;
case MESA_FORMAT_A_UNORM8:
- unpack_ubyte_A8(src, dst, n);
+ unpack_ubyte_A_UNORM8(src, dst, n);
break;
case MESA_FORMAT_L_UNORM8:
- unpack_ubyte_L8(src, dst, n);
+ unpack_ubyte_L_UNORM8(src, dst, n);
break;
case MESA_FORMAT_I_UNORM8:
- unpack_ubyte_I8(src, dst, n);
+ unpack_ubyte_I_UNORM8(src, dst, n);
break;
case MESA_FORMAT_R_UNORM8:
- unpack_ubyte_R8(src, dst, n);
+ unpack_ubyte_R_UNORM8(src, dst, n);
break;
case MESA_FORMAT_R8G8_UNORM:
- unpack_ubyte_GR88(src, dst, n);
+ unpack_ubyte_R8G8_UNORM(src, dst, n);
break;
case MESA_FORMAT_G8R8_UNORM:
- unpack_ubyte_RG88(src, dst, n);
+ unpack_ubyte_G8R8_UNORM(src, dst, n);
break;
default:
/* get float values, convert to ubyte */
@@ -3123,7 +3123,7 @@ unpack_int_rgba_RGBA_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
}
static void
-unpack_int_rgba_ARGB8888(const GLbyte *src, GLuint dst[][4], GLuint n)
+unpack_int_rgba_B8G8R8A8_UNORM(const GLbyte *src, GLuint dst[][4], GLuint n)
{
unsigned int i;
@@ -3136,7 +3136,7 @@ unpack_int_rgba_ARGB8888(const GLbyte *src, GLuint dst[][4], GLuint n)
}
static void
-unpack_int_rgba_XRGB8888(const GLbyte *src, GLuint dst[][4], GLuint n)
+unpack_int_rgba_B8G8R8X8_UNORM(const GLbyte *src, GLuint dst[][4], GLuint n)
{
unsigned int i;
@@ -3560,7 +3560,7 @@ unpack_int_rgba_INTENSITY_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
}
static void
-unpack_int_rgba_ARGB2101010_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
+unpack_int_rgba_B10G10R10A2_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
{
unsigned int i;
@@ -3574,7 +3574,7 @@ unpack_int_rgba_ARGB2101010_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
}
static void
-unpack_int_rgba_ABGR2101010_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
+unpack_int_rgba_R10G10B10A2_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
{
unsigned int i;
@@ -3588,7 +3588,7 @@ unpack_int_rgba_ABGR2101010_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
}
static void
-unpack_int_rgba_ARGB2101010(const GLuint *src, GLuint dst[][4], GLuint n)
+unpack_int_rgba_B10G10R10A2_UNORM(const GLuint *src, GLuint dst[][4], GLuint n)
{
unsigned int i;
@@ -3667,7 +3667,7 @@ unpack_int_rgba_XBGR32323232_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
}
static void
-unpack_int_rgba_ABGR2101010(const GLuint *src, GLuint dst[][4], GLuint n)
+unpack_int_rgba_R10G10B10A2_UNORM(const GLuint *src, GLuint dst[][4], GLuint n)
{
unsigned int i;
@@ -3708,11 +3708,11 @@ _mesa_unpack_uint_rgba_row(mesa_format format, GLuint n,
break;
case MESA_FORMAT_B8G8R8A8_UNORM:
- unpack_int_rgba_ARGB8888(src, dst, n);
+ unpack_int_rgba_B8G8R8A8_UNORM(src, dst, n);
break;
case MESA_FORMAT_B8G8R8X8_UNORM:
- unpack_int_rgba_XRGB8888(src, dst, n);
+ unpack_int_rgba_B8G8R8X8_UNORM(src, dst, n);
break;
case MESA_FORMAT_RGB_UINT32:
@@ -3848,15 +3848,15 @@ _mesa_unpack_uint_rgba_row(mesa_format format, GLuint n,
break;
case MESA_FORMAT_B10G10R10A2_UINT:
- unpack_int_rgba_ARGB2101010_UINT(src, dst, n);
+ unpack_int_rgba_B10G10R10A2_UINT(src, dst, n);
break;
case MESA_FORMAT_R10G10B10A2_UINT:
- unpack_int_rgba_ABGR2101010_UINT(src, dst, n);
+ unpack_int_rgba_R10G10B10A2_UINT(src, dst, n);
break;
case MESA_FORMAT_B10G10R10A2_UNORM:
- unpack_int_rgba_ARGB2101010(src, dst, n);
+ unpack_int_rgba_B10G10R10A2_UNORM(src, dst, n);
break;
case MESA_FORMAT_RGBX_UINT8:
@@ -3881,7 +3881,7 @@ _mesa_unpack_uint_rgba_row(mesa_format format, GLuint n,
break;
case MESA_FORMAT_R10G10B10A2_UNORM:
- unpack_int_rgba_ABGR2101010(src, dst, n);
+ unpack_int_rgba_R10G10B10A2_UNORM(src, dst, n);
break;
default:
@@ -3963,7 +3963,7 @@ unpack_float_z_X8_Z24(GLuint n, const void *src, GLfloat *dst)
}
static void
-unpack_float_z_Z16(GLuint n, const void *src, GLfloat *dst)
+unpack_float_Z_UNORM16(GLuint n, const void *src, GLfloat *dst)
{
const GLushort *s = ((const GLushort *) src);
GLuint i;
@@ -3973,7 +3973,7 @@ unpack_float_z_Z16(GLuint n, const void *src, GLfloat *dst)
}
static void
-unpack_float_z_Z32(GLuint n, const void *src, GLfloat *dst)
+unpack_float_Z_UNORM32(GLuint n, const void *src, GLfloat *dst)
{
const GLuint *s = ((const GLuint *) src);
GLuint i;
@@ -4020,10 +4020,10 @@ _mesa_unpack_float_z_row(mesa_format format, GLuint n,
unpack = unpack_float_z_X8_Z24;
break;
case MESA_FORMAT_Z_UNORM16:
- unpack = unpack_float_z_Z16;
+ unpack = unpack_float_Z_UNORM16;
break;
case MESA_FORMAT_Z_UNORM32:
- unpack = unpack_float_z_Z32;
+ unpack = unpack_float_Z_UNORM32;
break;
case MESA_FORMAT_Z_FLOAT32:
unpack = unpack_float_z_Z32F;
@@ -4067,7 +4067,7 @@ unpack_uint_z_X8_Z24(const void *src, GLuint *dst, GLuint n)
}
static void
-unpack_uint_z_Z16(const void *src, GLuint *dst, GLuint n)
+unpack_uint_Z_UNORM16(const void *src, GLuint *dst, GLuint n)
{
const GLushort *s = ((const GLushort *)src);
GLuint i;
@@ -4077,13 +4077,13 @@ unpack_uint_z_Z16(const void *src, GLuint *dst, GLuint n)
}
static void
-unpack_uint_z_Z32(const void *src, GLuint *dst, GLuint n)
+unpack_uint_Z_UNORM32(const void *src, GLuint *dst, GLuint n)
{
memcpy(dst, src, n * sizeof(GLuint));
}
static void
-unpack_uint_z_Z32_FLOAT(const void *src, GLuint *dst, GLuint n)
+unpack_uint_Z_FLOAT32(const void *src, GLuint *dst, GLuint n)
{
const float *s = (const float *)src;
GLuint i;
@@ -4093,7 +4093,7 @@ unpack_uint_z_Z32_FLOAT(const void *src, GLuint *dst, GLuint n)
}
static void
-unpack_uint_z_Z32_FLOAT_X24S8(const void *src, GLuint *dst, GLuint n)
+unpack_uint_Z_FLOAT32_X24S8(const void *src, GLuint *dst, GLuint n)
{
const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
GLuint i;
@@ -4125,16 +4125,16 @@ _mesa_unpack_uint_z_row(mesa_format format, GLuint n,
unpack = unpack_uint_z_X8_Z24;
break;
case MESA_FORMAT_Z_UNORM16:
- unpack = unpack_uint_z_Z16;
+ unpack = unpack_uint_Z_UNORM16;
break;
case MESA_FORMAT_Z_UNORM32:
- unpack = unpack_uint_z_Z32;
+ unpack = unpack_uint_Z_UNORM32;
break;
case MESA_FORMAT_Z_FLOAT32:
- unpack = unpack_uint_z_Z32_FLOAT;
+ unpack = unpack_uint_Z_FLOAT32;
break;
case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
- unpack = unpack_uint_z_Z32_FLOAT_X24S8;
+ unpack = unpack_uint_Z_FLOAT32_X24S8;
break;
default:
_mesa_problem(NULL, "bad format %s in _mesa_unpack_uint_z_row",
diff --git a/mesalib/src/mesa/main/formats.c b/mesalib/src/mesa/main/formats.c
index fb2501c69..4fb1f116b 100644
--- a/mesalib/src/mesa/main/formats.c
+++ b/mesalib/src/mesa/main/formats.c
@@ -3153,9 +3153,9 @@ _mesa_format_matches_format_and_type(mesa_format mesa_format,
case MESA_FORMAT_L_UNORM16:
return format == GL_LUMINANCE && type == GL_UNSIGNED_SHORT && !swapBytes;
case MESA_FORMAT_I_UNORM8:
- return format == GL_RED && type == GL_UNSIGNED_BYTE;
+ return format == GL_INTENSITY && type == GL_UNSIGNED_BYTE;
case MESA_FORMAT_I_UNORM16:
- return format == GL_RED && type == GL_UNSIGNED_SHORT && !swapBytes;
+ return format == GL_INTENSITY && type == GL_UNSIGNED_SHORT && !swapBytes;
case MESA_FORMAT_YCBCR:
return format == GL_YCBCR_MESA &&
@@ -3247,9 +3247,9 @@ _mesa_format_matches_format_and_type(mesa_format mesa_format,
return format == GL_LUMINANCE_ALPHA && type == GL_HALF_FLOAT && !swapBytes;
case MESA_FORMAT_I_FLOAT32:
- return format == GL_RED && type == GL_FLOAT && !swapBytes;
+ return format == GL_INTENSITY && type == GL_FLOAT && !swapBytes;
case MESA_FORMAT_I_FLOAT16:
- return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes;
+ return format == GL_INTENSITY && type == GL_HALF_FLOAT && !swapBytes;
case MESA_FORMAT_R_FLOAT32:
return format == GL_RED && type == GL_FLOAT && !swapBytes;
@@ -3277,17 +3277,13 @@ _mesa_format_matches_format_and_type(mesa_format mesa_format,
return format == GL_ALPHA_INTEGER && type == GL_INT && !swapBytes;
case MESA_FORMAT_I_UINT8:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE;
case MESA_FORMAT_I_UINT16:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes;
case MESA_FORMAT_I_UINT32:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
case MESA_FORMAT_I_SINT8:
- return format == GL_RED_INTEGER && type == GL_BYTE;
case MESA_FORMAT_I_SINT16:
- return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes;
case MESA_FORMAT_I_SINT32:
- return format == GL_RED_INTEGER && type == GL_INT && !swapBytes;
+ /* GL_INTENSITY_INTEGER_EXT doesn't exist. */
+ return GL_FALSE;
case MESA_FORMAT_L_UINT8:
return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_BYTE;
@@ -3454,7 +3450,7 @@ _mesa_format_matches_format_and_type(mesa_format mesa_format,
return format == GL_LUMINANCE_ALPHA && type == GL_BYTE &&
littleEndian && !swapBytes;
case MESA_FORMAT_I_SNORM8:
- return format == GL_RED && type == GL_BYTE;
+ return format == GL_INTENSITY && type == GL_BYTE;
case MESA_FORMAT_A_SNORM16:
return format == GL_ALPHA && type == GL_SHORT && !swapBytes;
case MESA_FORMAT_L_SNORM16:
@@ -3463,7 +3459,7 @@ _mesa_format_matches_format_and_type(mesa_format mesa_format,
return format == GL_LUMINANCE_ALPHA && type == GL_SHORT &&
littleEndian && !swapBytes;
case MESA_FORMAT_I_SNORM16:
- return format == GL_RED && type == GL_SHORT && littleEndian &&
+ return format == GL_INTENSITY && type == GL_SHORT && littleEndian &&
!swapBytes;
case MESA_FORMAT_B10G10R10A2_UINT:
diff --git a/mesalib/src/mesa/main/get.c b/mesalib/src/mesa/main/get.c
index 88cf202df..6d9579008 100644
--- a/mesalib/src/mesa/main/get.c
+++ b/mesalib/src/mesa/main/get.c
@@ -387,6 +387,7 @@ EXTRA_EXT(ARB_texture_cube_map_array);
EXTRA_EXT(ARB_texture_buffer_range);
EXTRA_EXT(ARB_texture_multisample);
EXTRA_EXT(ARB_texture_gather);
+EXTRA_EXT(ARB_separate_shader_objects);
EXTRA_EXT(ARB_shader_atomic_counters);
EXTRA_EXT(ARB_draw_indirect);
EXTRA_EXT(ARB_shader_image_load_store);
@@ -873,6 +874,18 @@ find_custom_value(struct gl_context *ctx, const struct value_desc *d, union valu
v->value_int = ctx->TransformFeedback.CurrentObject->Name;
break;
case GL_CURRENT_PROGRAM:
+ /* The Changelog of the ARB_separate_shader_objects spec says:
+ *
+ * 24 25 Jul 2011 pbrown Remove the language erroneously deleting
+ * CURRENT_PROGRAM. In the EXT extension, this
+ * token was aliased to ACTIVE_PROGRAM_EXT, and
+ * was used to indicate the last program set by
+ * either ActiveProgramEXT or UseProgram. In
+ * the ARB extension, the SSO active programs
+ * are now program pipeline object state and
+ * CURRENT_PROGRAM should still be used to query
+ * the last program set by UseProgram (bug 7822).
+ */
v->value_int =
ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
break;
@@ -1002,6 +1015,14 @@ find_custom_value(struct gl_context *ctx, const struct value_desc *d, union valu
case GL_DRAW_INDIRECT_BUFFER_BINDING:
v->value_int = ctx->DrawIndirectBuffer->Name;
break;
+ /* GL_ARB_separate_shader_objects */
+ case GL_PROGRAM_PIPELINE_BINDING:
+ if (ctx->Pipeline.Current) {
+ v->value_int = ctx->Pipeline.Current->Name;
+ } else {
+ v->value_int = 0;
+ }
+ break;
}
}
diff --git a/mesalib/src/mesa/main/get_hash_params.py b/mesalib/src/mesa/main/get_hash_params.py
index 674d0032a..06d0bbacc 100644
--- a/mesalib/src/mesa/main/get_hash_params.py
+++ b/mesalib/src/mesa/main/get_hash_params.py
@@ -726,6 +726,9 @@ descriptor=[
[ "MAX_PROGRAM_TEXTURE_GATHER_OFFSET", "CONTEXT_INT(Const.MaxProgramTextureGatherOffset), extra_ARB_texture_gather"],
[ "MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB", "CONTEXT_INT(Const.MaxProgramTextureGatherComponents), extra_ARB_texture_gather"],
+# GL_ARB_separate_shader_objects
+ [ "PROGRAM_PIPELINE_BINDING", "LOC_CUSTOM, TYPE_INT, GL_PROGRAM_PIPELINE_BINDING, extra_ARB_separate_shader_objects" ],
+
# GL_ARB_shader_atomic_counters
[ "ATOMIC_COUNTER_BUFFER_BINDING", "LOC_CUSTOM, TYPE_INT, 0, extra_ARB_shader_atomic_counters" ],
[ "MAX_ATOMIC_COUNTER_BUFFER_BINDINGS", "CONTEXT_INT(Const.MaxAtomicBufferBindings), extra_ARB_shader_atomic_counters" ],
diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index c6d90c579..33cb88881 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -2807,6 +2807,10 @@ struct gl_pipeline_object
GLbitfield Flags; /**< Mask of GLSL_x flags */
GLboolean EverBound; /**< Has the pipeline object been created */
+
+ GLboolean Validated; /**< Pipeline Validation status */
+
+ GLchar *InfoLog;
};
/**
@@ -2817,6 +2821,9 @@ struct gl_pipeline_shader_state
/** Currently bound pipeline object. See _mesa_BindProgramPipeline() */
struct gl_pipeline_object *Current;
+ /* Default Object to ensure that _Shader is never NULL */
+ struct gl_pipeline_object *Default;
+
/** Pipeline objects */
struct _mesa_HashTable *Objects;
};
@@ -4123,6 +4130,26 @@ struct gl_context
struct gl_pipeline_shader_state Pipeline; /**< GLSL pipeline shader object state */
struct gl_pipeline_object Shader; /**< GLSL shader object state */
+
+ /**
+ * Current active shader pipeline state
+ *
+ * Almost all internal users want ::_Shader instead of ::Shader. The
+ * exceptions are bits of legacy GLSL API that do not know about separate
+ * shader objects.
+ *
+ * If a program is active via \c glUseProgram, this will point to
+ * \c ::Shader.
+ *
+ * If a program pipeline is active via \c glBindProgramPipeline, this will
+ * point to \c ::Pipeline.Current.
+ *
+ * If neither a program nor a program pipeline is active, this will point to
+ * \c ::Pipeline.Default. This ensures that \c ::_Shader will never be
+ * \c NULL.
+ */
+ struct gl_pipeline_object *_Shader;
+
struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_STAGES];
struct gl_query_state Query; /**< occlusion, timer queries */
diff --git a/mesalib/src/mesa/main/pipelineobj.c b/mesalib/src/mesa/main/pipelineobj.c
index 27012df72..f55251e06 100644
--- a/mesalib/src/mesa/main/pipelineobj.c
+++ b/mesalib/src/mesa/main/pipelineobj.c
@@ -80,6 +80,7 @@ _mesa_new_pipeline_object(struct gl_context *ctx, GLuint name)
mtx_init(&obj->Mutex, mtx_plain);
obj->RefCount = 1;
obj->Flags = _mesa_get_shader_flags();
+ obj->InfoLog = NULL;
}
return obj;
@@ -94,6 +95,10 @@ _mesa_init_pipeline(struct gl_context *ctx)
ctx->Pipeline.Objects = _mesa_NewHashTable();
ctx->Pipeline.Current = NULL;
+
+ /* Install a default Pipeline */
+ ctx->Pipeline.Default = _mesa_new_pipeline_object(ctx, 0);
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, ctx->Pipeline.Default);
}
@@ -117,6 +122,10 @@ _mesa_free_pipeline_data(struct gl_context *ctx)
{
_mesa_HashDeleteAll(ctx->Pipeline.Objects, delete_pipelineobj_cb, ctx);
_mesa_DeleteHashTable(ctx->Pipeline.Objects);
+
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, NULL);
+ _mesa_delete_pipeline_object(ctx, ctx->Pipeline.Default);
+
}
/**
@@ -214,6 +223,109 @@ _mesa_reference_pipeline_object_(struct gl_context *ctx,
void GLAPIENTRY
_mesa_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_pipeline_object *pipe = lookup_pipeline_object(ctx, pipeline);
+ struct gl_shader_program *shProg = NULL;
+ GLbitfield any_valid_stages;
+
+ if (!pipe) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glUseProgramStages(pipeline)");
+ return;
+ }
+
+ /* Object is created by any Pipeline call but glGenProgramPipelines,
+ * glIsProgramPipeline and GetProgramPipelineInfoLog
+ */
+ pipe->EverBound = GL_TRUE;
+
+ /* Section 2.11.4 (Program Pipeline Objects) of the OpenGL 4.1 spec says:
+ *
+ * "If stages is not the special value ALL_SHADER_BITS, and has a bit
+ * set that is not recognized, the error INVALID_VALUE is generated."
+ *
+ * NOT YET SUPPORTED:
+ * GL_TESS_CONTROL_SHADER_BIT
+ * GL_TESS_EVALUATION_SHADER_BIT
+ */
+ any_valid_stages = GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT;
+ if (_mesa_has_geometry_shaders(ctx))
+ any_valid_stages |= GL_GEOMETRY_SHADER_BIT;
+
+ if (stages != GL_ALL_SHADER_BITS && (stages & ~any_valid_stages) != 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glUseProgramStages(Stages)");
+ return;
+ }
+
+ /* Section 2.17.2 (Transform Feedback Primitive Capture) of the OpenGL 4.1
+ * spec says:
+ *
+ * "The error INVALID_OPERATION is generated:
+ *
+ * ...
+ *
+ * - by UseProgramStages if the program pipeline object it refers
+ * to is current and the current transform feedback object is
+ * active and not paused;
+ */
+ if (ctx->_Shader == pipe) {
+ if (_mesa_is_xfb_active_and_unpaused(ctx)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glUseProgramStages(transform feedback active)");
+ return;
+ }
+ }
+
+ if (program) {
+ shProg = _mesa_lookup_shader_program_err(ctx, program,
+ "glUseProgramStages");
+ if (shProg == NULL)
+ return;
+
+ /* Section 2.11.4 (Program Pipeline Objects) of the OpenGL 4.1 spec
+ * says:
+ *
+ * "If the program object named by program was linked without the
+ * PROGRAM_SEPARABLE parameter set, or was not linked successfully,
+ * the error INVALID_OPERATION is generated and the corresponding
+ * shader stages in the pipeline program pipeline object are not
+ * modified."
+ */
+ if (!shProg->LinkStatus) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glUseProgramStages(program not linked)");
+ return;
+ }
+
+ if (!shProg->SeparateShader) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glUseProgramStages(program wasn't linked with the "
+ "PROGRAM_SEPARABLE flag)");
+ return;
+ }
+ }
+
+ /* Enable individual stages from the program as requested by the
+ * application. If there is no shader for a requested stage in the
+ * program, _mesa_use_shader_program will enable fixed-function processing
+ * as dictated by the spec.
+ *
+ * Section 2.11.4 (Program Pipeline Objects) of the OpenGL 4.1 spec
+ * says:
+ *
+ * "If UseProgramStages is called with program set to zero or with a
+ * program object that contains no executable code for the given
+ * stages, it is as if the pipeline object has no programmable stage
+ * configured for the indicated shader stages."
+ */
+ if ((stages & GL_VERTEX_SHADER_BIT) != 0)
+ _mesa_use_shader_program(ctx, GL_VERTEX_SHADER, shProg, pipe);
+
+ if ((stages & GL_FRAGMENT_SHADER_BIT) != 0)
+ _mesa_use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg, pipe);
+
+ if ((stages & GL_GEOMETRY_SHADER_BIT) != 0)
+ _mesa_use_shader_program(ctx, GL_GEOMETRY_SHADER, shProg, pipe);
}
/**
@@ -259,6 +371,75 @@ _mesa_ActiveShaderProgram(GLuint pipeline, GLuint program)
void GLAPIENTRY
_mesa_BindProgramPipeline(GLuint pipeline)
{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_pipeline_object *newObj = NULL;
+
+ /* Rebinding the same pipeline object: no change.
+ */
+ if (ctx->_Shader->Name == pipeline)
+ return;
+
+ /* Section 2.17.2 (Transform Feedback Primitive Capture) of the OpenGL 4.1
+ * spec says:
+ *
+ * "The error INVALID_OPERATION is generated:
+ *
+ * ...
+ *
+ * - by BindProgramPipeline if the current transform feedback
+ * object is active and not paused;
+ */
+ if (_mesa_is_xfb_active_and_unpaused(ctx)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glBindProgramPipeline(transform feedback active)");
+ return;
+ }
+
+ /* Get pointer to new pipeline object (newObj)
+ */
+ if (pipeline) {
+ /* non-default pipeline object */
+ newObj = lookup_pipeline_object(ctx, pipeline);
+ if (!newObj) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glBindProgramPipeline(non-gen name)");
+ return;
+ }
+
+ /* Object is created by any Pipeline call but glGenProgramPipelines,
+ * glIsProgramPipeline and GetProgramPipelineInfoLog
+ */
+ newObj->EverBound = GL_TRUE;
+ }
+
+ /* First bind the Pipeline to pipeline binding point */
+ _mesa_reference_pipeline_object(ctx, &ctx->Pipeline.Current, newObj);
+
+ /* Section 2.11.3 (Program Objects) of the OpenGL 4.1 spec says:
+ *
+ * "If there is a current program object established by UseProgram,
+ * that program is considered current for all stages. Otherwise, if
+ * there is a bound program pipeline object (see section 2.11.4), the
+ * program bound to the appropriate stage of the pipeline object is
+ * considered current."
+ */
+ if (&ctx->Shader != ctx->_Shader) {
+ if (pipeline) {
+ /* Bound the pipeline to the current program and
+ * restore the pipeline state
+ */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, newObj);
+ } else {
+ /* Unbind the pipeline */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader,
+ ctx->Pipeline.Default);
+ }
+
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
+
+ if (ctx->Driver.UseProgram)
+ ctx->Driver.UseProgram(ctx, NULL);
+ }
}
/**
@@ -393,14 +574,10 @@ _mesa_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
*params = pipe->ActiveProgram ? pipe->ActiveProgram->Name : 0;
return;
case GL_INFO_LOG_LENGTH:
- /* FINISHME: Implement the info log.
- */
- *params = 0;
+ *params = pipe->InfoLog ? strlen(pipe->InfoLog) + 1 : 0;
return;
case GL_VALIDATE_STATUS:
- /* FINISHME: Implement validation status.
- */
- *params = 0;
+ *params = pipe->Validated;
return;
case GL_VERTEX_SHADER:
*params = pipe->CurrentProgram[MESA_SHADER_VERTEX]
@@ -431,15 +608,222 @@ _mesa_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
}
/**
+ * Determines whether every stage in a linked program is active in the
+ * specified pipeline.
+ */
+static bool
+program_stages_all_active(struct gl_pipeline_object *pipe,
+ const struct gl_shader_program *prog)
+{
+ unsigned i;
+ bool status = true;
+
+ if (!prog)
+ return true;
+
+ for (i = 0; i < MESA_SHADER_STAGES; i++) {
+ if (prog->_LinkedShaders[i]) {
+ if (pipe->CurrentProgram[i]) {
+ if (prog->Name != pipe->CurrentProgram[i]->Name) {
+ status = false;
+ }
+ } else {
+ status = false;
+ }
+ }
+ }
+
+ if (!status) {
+ pipe->InfoLog = ralloc_asprintf(pipe,
+ "Program %d is not active for all "
+ "shaders that was linked",
+ prog->Name);
+ }
+
+ return status;
+}
+
+extern GLboolean
+_mesa_validate_program_pipeline(struct gl_context* ctx,
+ struct gl_pipeline_object *pipe,
+ GLboolean IsBound)
+{
+ unsigned i;
+
+ pipe->Validated = GL_FALSE;
+
+ /* Release and reset the info log.
+ */
+ if (pipe->InfoLog != NULL)
+ ralloc_free(pipe->InfoLog);
+
+ pipe->InfoLog = NULL;
+
+ /* Section 2.11.11 (Shader Execution), subheading "Validation," of the
+ * OpenGL 4.1 spec says:
+ *
+ * "[INVALID_OPERATION] is generated by any command that transfers
+ * vertices to the GL if:
+ *
+ * - A program object is active for at least one, but not all of
+ * the shader stages that were present when the program was
+ * linked."
+ *
+ * For each possible program stage, verify that the program bound to that
+ * stage has all of its stages active. In other words, if the program
+ * bound to the vertex stage also has a fragment shader, the fragment
+ * shader must also be bound to the fragment stage.
+ */
+ for (i = 0; i < MESA_SHADER_STAGES; i++) {
+ if (!program_stages_all_active(pipe, pipe->CurrentProgram[i])) {
+ goto err;
+ }
+ }
+
+ /* Section 2.11.11 (Shader Execution), subheading "Validation," of the
+ * OpenGL 4.1 spec says:
+ *
+ * "[INVALID_OPERATION] is generated by any command that transfers
+ * vertices to the GL if:
+ *
+ * ...
+ *
+ * - One program object is active for at least two shader stages
+ * and a second program is active for a shader stage between two
+ * stages for which the first program was active."
+ *
+ * Without Tesselation, the only case where this can occur is the geometry
+ * shader between the fragment shader and vertex shader.
+ */
+ if (pipe->CurrentProgram[MESA_SHADER_GEOMETRY]
+ && pipe->CurrentProgram[MESA_SHADER_FRAGMENT]
+ && pipe->CurrentProgram[MESA_SHADER_VERTEX]) {
+ if (pipe->CurrentProgram[MESA_SHADER_VERTEX]->Name == pipe->CurrentProgram[MESA_SHADER_FRAGMENT]->Name &&
+ pipe->CurrentProgram[MESA_SHADER_GEOMETRY]->Name != pipe->CurrentProgram[MESA_SHADER_VERTEX]->Name) {
+ pipe->InfoLog =
+ ralloc_asprintf(pipe,
+ "Program %d is active for geometry stage between "
+ "two stages for which another program %d is "
+ "active",
+ pipe->CurrentProgram[MESA_SHADER_GEOMETRY]->Name,
+ pipe->CurrentProgram[MESA_SHADER_VERTEX]->Name);
+ goto err;
+ }
+ }
+
+ /* Section 2.11.11 (Shader Execution), subheading "Validation," of the
+ * OpenGL 4.1 spec says:
+ *
+ * "[INVALID_OPERATION] is generated by any command that transfers
+ * vertices to the GL if:
+ *
+ * ...
+ *
+ * - There is an active program for tessellation control,
+ * tessellation evaluation, or geometry stages with corresponding
+ * executable shader, but there is no active program with
+ * executable vertex shader."
+ */
+ if (!pipe->CurrentProgram[MESA_SHADER_VERTEX]
+ && pipe->CurrentProgram[MESA_SHADER_GEOMETRY]) {
+ pipe->InfoLog = ralloc_strdup(pipe, "Program lacks a vertex shader");
+ goto err;
+ }
+
+ /* Section 2.11.11 (Shader Execution), subheading "Validation," of the
+ * OpenGL 4.1 spec says:
+ *
+ * "[INVALID_OPERATION] is generated by any command that transfers
+ * vertices to the GL if:
+ *
+ * ...
+ *
+ * - There is no current program object specified by UseProgram,
+ * there is a current program pipeline object, and the current
+ * program for any shader stage has been relinked since being
+ * applied to the pipeline object via UseProgramStages with the
+ * PROGRAM_SEPARABLE parameter set to FALSE.
+ */
+ for (i = 0; i < MESA_SHADER_STAGES; i++) {
+ if (pipe->CurrentProgram[i] && !pipe->CurrentProgram[i]->SeparateShader) {
+ pipe->InfoLog = ralloc_asprintf(pipe,
+ "Program %d was relinked without "
+ "PROGRAM_SEPARABLE state",
+ pipe->CurrentProgram[i]->Name);
+ goto err;
+ }
+ }
+
+ /* Section 2.11.11 (Shader Execution), subheading "Validation," of the
+ * OpenGL 4.1 spec says:
+ *
+ * "[INVALID_OPERATION] is generated by any command that transfers
+ * vertices to the GL if:
+ *
+ * ...
+ *
+ * - Any two active samplers in the current program object are of
+ * different types, but refer to the same texture image unit.
+ *
+ * - The number of active samplers in the program exceeds the
+ * maximum number of texture image units allowed."
+ */
+ if (!_mesa_sampler_uniforms_pipeline_are_valid(pipe))
+ goto err;
+
+ pipe->Validated = GL_TRUE;
+ return GL_TRUE;
+
+err:
+ if (IsBound)
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glValidateProgramPipeline failed to validate the pipeline");
+
+ return GL_FALSE;
+}
+
+/**
* Check compatibility of pipeline's program
*/
void GLAPIENTRY
_mesa_ValidateProgramPipeline(GLuint pipeline)
{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_pipeline_object *pipe = lookup_pipeline_object(ctx, pipeline);
+
+ if (!pipe) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glValidateProgramPipeline(pipeline)");
+ return;
+ }
+
+ _mesa_validate_program_pipeline(ctx, pipe,
+ (ctx->_Shader->Name == pipe->Name));
}
void GLAPIENTRY
_mesa_GetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize,
GLsizei *length, GLchar *infoLog)
{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_pipeline_object *pipe = lookup_pipeline_object(ctx, pipeline);
+
+ if (!pipe) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glGetProgramPipelineInfoLog(pipeline)");
+ return;
+ }
+
+ if (bufSize < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glGetProgramPipelineInfoLog(bufSize)");
+ return;
+ }
+
+ if (pipe->InfoLog)
+ _mesa_copy_string(infoLog, bufSize, length, pipe->InfoLog);
+ else
+ *length = 0;
}
diff --git a/mesalib/src/mesa/main/pipelineobj.h b/mesalib/src/mesa/main/pipelineobj.h
index 46d5fab42..ceaf4f14c 100644
--- a/mesalib/src/mesa/main/pipelineobj.h
+++ b/mesalib/src/mesa/main/pipelineobj.h
@@ -59,6 +59,9 @@ _mesa_reference_pipeline_object(struct gl_context *ctx,
_mesa_reference_pipeline_object_(ctx, ptr, obj);
}
+extern GLboolean
+_mesa_validate_program_pipeline(struct gl_context * ctx, struct gl_pipeline_object *pipe, GLboolean IsBound);
+
extern void GLAPIENTRY
_mesa_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
diff --git a/mesalib/src/mesa/main/shaderapi.c b/mesalib/src/mesa/main/shaderapi.c
index 5060cbb0b..1c8e6b4cf 100644
--- a/mesalib/src/mesa/main/shaderapi.c
+++ b/mesalib/src/mesa/main/shaderapi.c
@@ -44,6 +44,7 @@
#include "main/hash.h"
#include "main/hash_table.h"
#include "main/mtypes.h"
+#include "main/pipelineobj.h"
#include "main/shaderapi.h"
#include "main/shaderobj.h"
#include "main/transformfeedback.h"
@@ -144,6 +145,8 @@ _mesa_free_shader_state(struct gl_context *ctx)
_mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);
/* Extended for ARB_separate_shader_objects */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, NULL);
+
assert(ctx->Shader.RefCount == 1);
mtx_destroy(&ctx->Shader.Mutex);
}
@@ -465,8 +468,8 @@ static GLuint
get_handle(struct gl_context *ctx, GLenum pname)
{
if (pname == GL_PROGRAM_OBJECT_ARB) {
- if (ctx->Shader.ActiveProgram)
- return ctx->Shader.ActiveProgram->Name;
+ if (ctx->_Shader->ActiveProgram)
+ return ctx->_Shader->ActiveProgram->Name;
else
return 0;
}
@@ -837,7 +840,7 @@ compile_shader(struct gl_context *ctx, GLuint shaderObj)
*/
sh->CompileStatus = GL_FALSE;
} else {
- if (ctx->Shader.Flags & GLSL_DUMP) {
+ if (ctx->_Shader->Flags & GLSL_DUMP) {
fprintf(stderr, "GLSL source for %s shader %d:\n",
_mesa_shader_stage_to_string(sh->Stage), sh->Name);
fprintf(stderr, "%s\n", sh->Source);
@@ -849,11 +852,11 @@ compile_shader(struct gl_context *ctx, GLuint shaderObj)
*/
_mesa_glsl_compile_shader(ctx, sh, false, false);
- if (ctx->Shader.Flags & GLSL_LOG) {
+ if (ctx->_Shader->Flags & GLSL_LOG) {
_mesa_write_shader_to_file(sh);
}
- if (ctx->Shader.Flags & GLSL_DUMP) {
+ if (ctx->_Shader->Flags & GLSL_DUMP) {
if (sh->CompileStatus) {
fprintf(stderr, "GLSL IR for shader %d:\n", sh->Name);
_mesa_print_ir(stderr, sh->ir, NULL);
@@ -871,7 +874,7 @@ compile_shader(struct gl_context *ctx, GLuint shaderObj)
}
if (!sh->CompileStatus) {
- if (ctx->Shader.Flags & GLSL_DUMP_ON_ERROR) {
+ if (ctx->_Shader->Flags & GLSL_DUMP_ON_ERROR) {
fprintf(stderr, "GLSL source for %s shader %d:\n",
_mesa_shader_stage_to_string(sh->Stage), sh->Name);
fprintf(stderr, "%s\n", sh->Source);
@@ -879,7 +882,7 @@ compile_shader(struct gl_context *ctx, GLuint shaderObj)
fflush(stderr);
}
- if (ctx->Shader.Flags & GLSL_REPORT_ERRORS) {
+ if (ctx->_Shader->Flags & GLSL_REPORT_ERRORS) {
_mesa_debug(ctx, "Error compiling shader %u:\n%s\n",
sh->Name, sh->InfoLog);
}
@@ -915,7 +918,7 @@ link_program(struct gl_context *ctx, GLuint program)
_mesa_glsl_link_shader(ctx, shProg);
if (shProg->LinkStatus == GL_FALSE &&
- (ctx->Shader.Flags & GLSL_REPORT_ERRORS)) {
+ (ctx->_Shader->Flags & GLSL_REPORT_ERRORS)) {
_mesa_debug(ctx, "Error linking program %u:\n%s\n",
shProg->Name, shProg->InfoLog);
}
@@ -986,17 +989,21 @@ _mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
*/
static void
use_shader_program(struct gl_context *ctx, GLenum type,
- struct gl_shader_program *shProg)
+ struct gl_shader_program *shProg,
+ struct gl_pipeline_object *shTarget)
{
struct gl_shader_program **target;
gl_shader_stage stage = _mesa_shader_enum_to_shader_stage(type);
- target = &ctx->Shader.CurrentProgram[stage];
+ target = &shTarget->CurrentProgram[stage];
if ((shProg == NULL) || (shProg->_LinkedShaders[stage] == NULL))
shProg = NULL;
if (*target != shProg) {
- FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
+ /* Program is current, flush it */
+ if (shTarget == ctx->_Shader) {
+ FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
+ }
/* If the shader is also bound as the current rendering shader, unbind
* it from that binding point as well. This ensures that the correct
@@ -1013,9 +1020,9 @@ use_shader_program(struct gl_context *ctx, GLenum type,
/* Empty for now. */
break;
case GL_FRAGMENT_SHADER:
- if (*target == ctx->Shader._CurrentFragmentProgram) {
+ if (*target == ctx->_Shader->_CurrentFragmentProgram) {
_mesa_reference_shader_program(ctx,
- &ctx->Shader._CurrentFragmentProgram,
+ &ctx->_Shader->_CurrentFragmentProgram,
NULL);
}
break;
@@ -1032,10 +1039,10 @@ use_shader_program(struct gl_context *ctx, GLenum type,
void
_mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
{
- use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
- use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
- use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
- use_shader_program(ctx, GL_COMPUTE_SHADER, shProg);
+ use_shader_program(ctx, GL_VERTEX_SHADER, shProg, &ctx->Shader);
+ use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg, &ctx->Shader);
+ use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg, &ctx->Shader);
+ use_shader_program(ctx, GL_COMPUTE_SHADER, shProg, &ctx->Shader);
_mesa_active_program(ctx, shProg, "glUseProgram");
if (ctx->Driver.UseProgram)
@@ -1533,7 +1540,7 @@ _mesa_UseProgram(GLhandleARB program)
}
/* debug code */
- if (ctx->Shader.Flags & GLSL_USE_PROG) {
+ if (ctx->_Shader->Flags & GLSL_USE_PROG) {
print_shader_info(shProg);
}
}
@@ -1541,7 +1548,31 @@ _mesa_UseProgram(GLhandleARB program)
shProg = NULL;
}
- _mesa_use_program(ctx, shProg);
+ /* The "Dependencies on EXT_separate_shader_objects" section of the
+ * ARB_separate_shader_object spec says:
+ *
+ * "The executable code for an individual shader stage is taken from
+ * the current program for that stage. If there is a current program
+ * object for any shader stage or for uniform updates established by
+ * UseProgram, UseShaderProgramEXT, or ActiveProgramEXT, the current
+ * program for that stage (if any) is considered current. Otherwise,
+ * if there is a bound program pipeline object ..."
+ */
+ if (program) {
+ /* Attach shader state to the binding point */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
+ /* Update the program */
+ _mesa_use_program(ctx, shProg);
+ } else {
+ /* Must be done first: detach the progam */
+ _mesa_use_program(ctx, shProg);
+ /* Unattach shader_state binding point */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, ctx->Pipeline.Default);
+ /* If a pipeline was bound, rebind it */
+ if (ctx->Pipeline.Current) {
+ _mesa_BindProgramPipeline(ctx->Pipeline.Current->Name);
+ }
+ }
}
@@ -1773,9 +1804,10 @@ _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value)
void
_mesa_use_shader_program(struct gl_context *ctx, GLenum type,
- struct gl_shader_program *shProg)
+ struct gl_shader_program *shProg,
+ struct gl_pipeline_object *shTarget)
{
- use_shader_program(ctx, type, shProg);
+ use_shader_program(ctx, type, shProg, shTarget);
if (ctx->Driver.UseProgram)
ctx->Driver.UseProgram(ctx, shProg);
@@ -1815,7 +1847,41 @@ _mesa_UseShaderProgramEXT(GLenum type, GLuint program)
}
}
- _mesa_use_shader_program(ctx, type, shProg);
+ /* The "Dependencies on EXT_separate_shader_objects" section of the
+ * ARB_separate_shader_object spec says:
+ *
+ * "The executable code for an individual shader stage is taken from
+ * the current program for that stage. If there is a current program
+ * object for any shader stage or for uniform updates established by
+ * UseProgram, UseShaderProgramEXT, or ActiveProgramEXT, the current
+ * program for that stage (if any) is considered current. Otherwise,
+ * if there is a bound program pipeline object ..."
+ */
+ if (program) {
+ /* Attach shader state to the binding point */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
+ /* Update the program */
+ _mesa_use_shader_program(ctx, type, shProg, ctx->_Shader);
+ } else {
+ /* Must be done first: detach the progam */
+ _mesa_use_shader_program(ctx, type, shProg, ctx->_Shader);
+
+ /* Nothing remains current */
+ if (!ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] &&
+ !ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY] &&
+ !ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT] &&
+ !ctx->Shader.ActiveProgram) {
+
+ /* Unattach shader_state binding point */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader,
+ ctx->Pipeline.Default);
+
+ /* If a pipeline was bound, rebind it */
+ if (ctx->Pipeline.Current) {
+ _mesa_BindProgramPipeline(ctx->Pipeline.Current->Name);
+ }
+ }
+ }
}
@@ -1830,7 +1896,39 @@ _mesa_ActiveProgramEXT(GLuint program)
? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
: NULL;
- _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
+ /* The "Dependencies on EXT_separate_shader_objects" section of the
+ * ARB_separate_shader_object spec says:
+ *
+ * "The executable code for an individual shader stage is taken from
+ * the current program for that stage. If there is a current program
+ * object for any shader stage or for uniform updates established by
+ * UseProgram, UseShaderProgramEXT, or ActiveProgramEXT, the current
+ * program for that stage (if any) is considered current. Otherwise,
+ * if there is a bound program pipeline object ..."
+ */
+ if (shProg != NULL) {
+ /* Attach shader state to the binding point */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, &ctx->Shader);
+ _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
+ } else {
+ /* Must be done first: unset the current active progam */
+ _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
+
+ /* Nothing remains current */
+ if (!ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] &&
+ !ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY] &&
+ !ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT] &&
+ !ctx->Shader.ActiveProgram) {
+
+ /* Unattach shader_state binding point */
+ _mesa_reference_pipeline_object(ctx, &ctx->_Shader, ctx->Pipeline.Default);
+ /* If a pipeline was bound, rebind it */
+ if (ctx->Pipeline.Current) {
+ _mesa_BindProgramPipeline(ctx->Pipeline.Current->Name);
+ }
+ }
+ }
+
return;
}
diff --git a/mesalib/src/mesa/main/shaderapi.h b/mesalib/src/mesa/main/shaderapi.h
index 44426cc65..17b05b313 100644
--- a/mesalib/src/mesa/main/shaderapi.h
+++ b/mesalib/src/mesa/main/shaderapi.h
@@ -202,7 +202,8 @@ _mesa_ProgramParameteri(GLuint program, GLenum pname, GLint value);
void
_mesa_use_shader_program(struct gl_context *ctx, GLenum type,
- struct gl_shader_program *shProg);
+ struct gl_shader_program *shProg,
+ struct gl_pipeline_object *shTarget);
extern void GLAPIENTRY
_mesa_UseShaderProgramEXT(GLenum type, GLuint program);
diff --git a/mesalib/src/mesa/main/state.c b/mesalib/src/mesa/main/state.c
index 0866a140f..c122c16aa 100644
--- a/mesalib/src/mesa/main/state.c
+++ b/mesalib/src/mesa/main/state.c
@@ -95,11 +95,11 @@ static GLbitfield
update_program(struct gl_context *ctx)
{
const struct gl_shader_program *vsProg =
- ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
+ ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX];
const struct gl_shader_program *gsProg =
- ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
+ ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY];
struct gl_shader_program *fsProg =
- ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT];
+ ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT];
const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;
const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;
const struct gl_geometry_program *prevGP = ctx->GeometryProgram._Current;
@@ -125,7 +125,7 @@ update_program(struct gl_context *ctx)
&& fsProg->_LinkedShaders[MESA_SHADER_FRAGMENT]) {
/* Use GLSL fragment shader */
_mesa_reference_shader_program(ctx,
- &ctx->Shader._CurrentFragmentProgram,
+ &ctx->_Shader->_CurrentFragmentProgram,
fsProg);
_mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
gl_fragment_program(fsProg->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program));
@@ -135,7 +135,7 @@ update_program(struct gl_context *ctx)
else if (ctx->FragmentProgram._Enabled) {
/* Use user-defined fragment program */
_mesa_reference_shader_program(ctx,
- &ctx->Shader._CurrentFragmentProgram,
+ &ctx->_Shader->_CurrentFragmentProgram,
NULL);
_mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
ctx->FragmentProgram.Current);
@@ -147,7 +147,7 @@ update_program(struct gl_context *ctx)
struct gl_shader_program *f = _mesa_get_fixed_func_fragment_program(ctx);
_mesa_reference_shader_program(ctx,
- &ctx->Shader._CurrentFragmentProgram,
+ &ctx->_Shader->_CurrentFragmentProgram,
f);
_mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
gl_fragment_program(f->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program));
@@ -310,7 +310,7 @@ update_multisample(struct gl_context *ctx)
static void
update_twoside(struct gl_context *ctx)
{
- if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] ||
+ if (ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX] ||
ctx->VertexProgram._Enabled) {
ctx->VertexProgram._TwoSideEnabled = ctx->VertexProgram.TwoSideEnabled;
} else {
diff --git a/mesalib/src/mesa/main/texstate.c b/mesalib/src/mesa/main/texstate.c
index 08725f601..fcae878cf 100644
--- a/mesalib/src/mesa/main/texstate.c
+++ b/mesalib/src/mesa/main/texstate.c
@@ -532,9 +532,9 @@ update_texture_state( struct gl_context *ctx )
int i;
for (i = 0; i < MESA_SHADER_STAGES; i++) {
- if (ctx->Shader.CurrentProgram[i] &&
- ctx->Shader.CurrentProgram[i]->LinkStatus) {
- prog[i] = ctx->Shader.CurrentProgram[i]->_LinkedShaders[i]->Program;
+ if (ctx->_Shader->CurrentProgram[i] &&
+ ctx->_Shader->CurrentProgram[i]->LinkStatus) {
+ prog[i] = ctx->_Shader->CurrentProgram[i]->_LinkedShaders[i]->Program;
} else {
if (i == MESA_SHADER_FRAGMENT && ctx->FragmentProgram._Enabled)
prog[i] = &ctx->FragmentProgram.Current->Base;
diff --git a/mesalib/src/mesa/main/transformfeedback.c b/mesalib/src/mesa/main/transformfeedback.c
index 6b9565ca3..abeb25e87 100644
--- a/mesalib/src/mesa/main/transformfeedback.c
+++ b/mesalib/src/mesa/main/transformfeedback.c
@@ -388,8 +388,8 @@ get_xfb_source(struct gl_context *ctx)
{
int i;
for (i = MESA_SHADER_GEOMETRY; i >= MESA_SHADER_VERTEX; i--) {
- if (ctx->Shader.CurrentProgram[i] != NULL)
- return ctx->Shader.CurrentProgram[i];
+ if (ctx->_Shader->CurrentProgram[i] != NULL)
+ return ctx->_Shader->CurrentProgram[i];
}
return NULL;
}
diff --git a/mesalib/src/mesa/main/uniform_query.cpp b/mesalib/src/mesa/main/uniform_query.cpp
index fa13ef9fe..5f1af0873 100644
--- a/mesalib/src/mesa/main/uniform_query.cpp
+++ b/mesalib/src/mesa/main/uniform_query.cpp
@@ -698,7 +698,7 @@ _mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,
return;
}
- if (ctx->Shader.Flags & GLSL_UNIFORMS) {
+ if (ctx->_Shader->Flags & GLSL_UNIFORMS) {
log_uniform(values, basicType, components, 1, count,
false, shProg, location, uni);
}
@@ -920,7 +920,7 @@ _mesa_uniform_matrix(struct gl_context *ctx, struct gl_shader_program *shProg,
}
}
- if (ctx->Shader.Flags & GLSL_UNIFORMS) {
+ if (ctx->_Shader->Flags & GLSL_UNIFORMS) {
log_uniform(values, GLSL_TYPE_FLOAT, components, vectors, count,
bool(transpose), shProg, location, uni);
}
@@ -1089,3 +1089,80 @@ _mesa_sampler_uniforms_are_valid(const struct gl_shader_program *shProg,
return true;
}
+
+extern "C" bool
+_mesa_sampler_uniforms_pipeline_are_valid(struct gl_pipeline_object *pipeline)
+{
+ /* Section 2.11.11 (Shader Execution), subheading "Validation," of the
+ * OpenGL 4.1 spec says:
+ *
+ * "[INVALID_OPERATION] is generated by any command that transfers
+ * vertices to the GL if:
+ *
+ * ...
+ *
+ * - Any two active samplers in the current program object are of
+ * different types, but refer to the same texture image unit.
+ *
+ * - The number of active samplers in the program exceeds the
+ * maximum number of texture image units allowed."
+ */
+ unsigned active_samplers = 0;
+ const struct gl_shader_program **shProg =
+ (const struct gl_shader_program **) pipeline->CurrentProgram;
+
+ const glsl_type *unit_types[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
+ memset(unit_types, 0, sizeof(unit_types));
+
+ for (unsigned idx = 0; idx < ARRAY_SIZE(pipeline->CurrentProgram); idx++) {
+ if (!shProg[idx])
+ continue;
+
+ for (unsigned i = 0; i < shProg[idx]->NumUserUniformStorage; i++) {
+ const struct gl_uniform_storage *const storage =
+ &shProg[idx]->UniformStorage[i];
+ const glsl_type *const t = (storage->type->is_array())
+ ? storage->type->fields.array : storage->type;
+
+ if (!t->is_sampler())
+ continue;
+
+ active_samplers++;
+
+ const unsigned count = MAX2(1, storage->type->array_size());
+ for (unsigned j = 0; j < count; j++) {
+ const unsigned unit = storage->storage[j].i;
+
+ /* The types of the samplers associated with a particular texture
+ * unit must be an exact match. Page 74 (page 89 of the PDF) of
+ * the OpenGL 3.3 core spec says:
+ *
+ * "It is not allowed to have variables of different sampler
+ * types pointing to the same texture image unit within a
+ * program object."
+ */
+ if (unit_types[unit] == NULL) {
+ unit_types[unit] = t;
+ } else if (unit_types[unit] != t) {
+ pipeline->InfoLog =
+ ralloc_asprintf(pipeline,
+ "Texture unit %d is accessed both as %s "
+ "and %s",
+ unit, unit_types[unit]->name, t->name);
+ return false;
+ }
+ }
+ }
+ }
+
+ if (active_samplers > MAX_COMBINED_TEXTURE_IMAGE_UNITS) {
+ pipeline->InfoLog =
+ ralloc_asprintf(pipeline,
+ "the number of active samplers %d exceed the "
+ "maximum %d",
+ active_samplers, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+ return false;
+ }
+
+ return true;
+}
diff --git a/mesalib/src/mesa/main/uniforms.c b/mesalib/src/mesa/main/uniforms.c
index e9b374b0d..1daade428 100644
--- a/mesalib/src/mesa/main/uniforms.c
+++ b/mesalib/src/mesa/main/uniforms.c
@@ -137,7 +137,7 @@ void GLAPIENTRY
_mesa_Uniform1f(GLint location, GLfloat v0)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_FLOAT);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GL_FLOAT);
}
void GLAPIENTRY
@@ -147,7 +147,7 @@ _mesa_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
GLfloat v[2];
v[0] = v0;
v[1] = v1;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC2);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_FLOAT_VEC2);
}
void GLAPIENTRY
@@ -158,7 +158,7 @@ _mesa_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
v[0] = v0;
v[1] = v1;
v[2] = v2;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC3);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_FLOAT_VEC3);
}
void GLAPIENTRY
@@ -171,14 +171,14 @@ _mesa_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
v[1] = v1;
v[2] = v2;
v[3] = v3;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC4);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_FLOAT_VEC4);
}
void GLAPIENTRY
_mesa_Uniform1i(GLint location, GLint v0)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_INT);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GL_INT);
}
void GLAPIENTRY
@@ -188,7 +188,7 @@ _mesa_Uniform2i(GLint location, GLint v0, GLint v1)
GLint v[2];
v[0] = v0;
v[1] = v1;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC2);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_INT_VEC2);
}
void GLAPIENTRY
@@ -199,7 +199,7 @@ _mesa_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
v[0] = v0;
v[1] = v1;
v[2] = v2;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC3);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_INT_VEC3);
}
void GLAPIENTRY
@@ -211,63 +211,63 @@ _mesa_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
v[1] = v1;
v[2] = v2;
v[3] = v3;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC4);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_INT_VEC4);
}
void GLAPIENTRY
_mesa_Uniform1fv(GLint location, GLsizei count, const GLfloat * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_FLOAT);
}
void GLAPIENTRY
_mesa_Uniform2fv(GLint location, GLsizei count, const GLfloat * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC2);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_FLOAT_VEC2);
}
void GLAPIENTRY
_mesa_Uniform3fv(GLint location, GLsizei count, const GLfloat * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC3);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_FLOAT_VEC3);
}
void GLAPIENTRY
_mesa_Uniform4fv(GLint location, GLsizei count, const GLfloat * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC4);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_FLOAT_VEC4);
}
void GLAPIENTRY
_mesa_Uniform1iv(GLint location, GLsizei count, const GLint * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_INT);
}
void GLAPIENTRY
_mesa_Uniform2iv(GLint location, GLsizei count, const GLint * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC2);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_INT_VEC2);
}
void GLAPIENTRY
_mesa_Uniform3iv(GLint location, GLsizei count, const GLint * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC3);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_INT_VEC3);
}
void GLAPIENTRY
_mesa_Uniform4iv(GLint location, GLsizei count, const GLint * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC4);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_INT_VEC4);
}
/** Same as above with direct state access **/
@@ -467,7 +467,7 @@ void GLAPIENTRY
_mesa_Uniform1ui(GLint location, GLuint v0)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_UNSIGNED_INT);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, &v0, GL_UNSIGNED_INT);
}
void GLAPIENTRY
@@ -477,7 +477,7 @@ _mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1)
GLuint v[2];
v[0] = v0;
v[1] = v1;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC2);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC2);
}
void GLAPIENTRY
@@ -488,7 +488,7 @@ _mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
v[0] = v0;
v[1] = v1;
v[2] = v2;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC3);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC3);
}
void GLAPIENTRY
@@ -500,35 +500,35 @@ _mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
v[1] = v1;
v[2] = v2;
v[3] = v3;
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC4);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC4);
}
void GLAPIENTRY
_mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_UNSIGNED_INT);
}
void GLAPIENTRY
_mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC2);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC2);
}
void GLAPIENTRY
_mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC3);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC3);
}
void GLAPIENTRY
_mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC4);
+ _mesa_uniform(ctx, ctx->_Shader->ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC4);
}
@@ -538,7 +538,7 @@ _mesa_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
2, 2, location, count, transpose, value);
}
@@ -547,7 +547,7 @@ _mesa_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
3, 3, location, count, transpose, value);
}
@@ -556,7 +556,7 @@ _mesa_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat * value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
4, 4, location, count, transpose, value);
}
@@ -703,7 +703,7 @@ _mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
2, 3, location, count, transpose, value);
}
@@ -712,7 +712,7 @@ _mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
3, 2, location, count, transpose, value);
}
@@ -721,7 +721,7 @@ _mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
2, 4, location, count, transpose, value);
}
@@ -730,7 +730,7 @@ _mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
4, 2, location, count, transpose, value);
}
@@ -739,7 +739,7 @@ _mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
3, 4, location, count, transpose, value);
}
@@ -748,7 +748,7 @@ _mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
const GLfloat *value)
{
GET_CURRENT_CONTEXT(ctx);
- _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
+ _mesa_uniform_matrix(ctx, ctx->_Shader->ActiveProgram,
4, 3, location, count, transpose, value);
}
diff --git a/mesalib/src/mesa/main/uniforms.h b/mesalib/src/mesa/main/uniforms.h
index d7afdc106..c8b555cbe 100644
--- a/mesalib/src/mesa/main/uniforms.h
+++ b/mesalib/src/mesa/main/uniforms.h
@@ -300,6 +300,8 @@ _mesa_update_shader_textures_used(struct gl_shader_program *shProg,
extern bool
_mesa_sampler_uniforms_are_valid(const struct gl_shader_program *shProg,
char *errMsg, size_t errMsgLength);
+extern bool
+_mesa_sampler_uniforms_pipeline_are_valid(struct gl_pipeline_object *);
extern const struct gl_program_parameter *
get_uniform_parameter(struct gl_shader_program *shProg, GLint index);
diff --git a/mesalib/src/mesa/main/varray.c b/mesalib/src/mesa/main/varray.c
index b4b6fa9be..b88d70018 100644
--- a/mesalib/src/mesa/main/varray.c
+++ b/mesalib/src/mesa/main/varray.c
@@ -1223,7 +1223,7 @@ _mesa_MultiDrawArrays( GLenum mode, const GLint *first,
for (i = 0; i < primcount; i++) {
if (count[i] > 0) {
- CALL_DrawArrays(ctx->Exec, (mode, first[i], count[i]));
+ CALL_DrawArrays(ctx->CurrentDispatch, (mode, first[i], count[i]));
}
}
}
@@ -1243,7 +1243,7 @@ _mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first,
for ( i = 0 ; i < primcount ; i++ ) {
if ( count[i] > 0 ) {
GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
- CALL_DrawArrays(ctx->Exec, ( m, first[i], count[i] ));
+ CALL_DrawArrays(ctx->CurrentDispatch, ( m, first[i], count[i] ));
}
}
}
@@ -1265,7 +1265,8 @@ _mesa_MultiModeDrawElementsIBM( const GLenum * mode, const GLsizei * count,
for ( i = 0 ; i < primcount ; i++ ) {
if ( count[i] > 0 ) {
GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
- CALL_DrawElements(ctx->Exec, ( m, count[i], type, indices[i] ));
+ CALL_DrawElements(ctx->CurrentDispatch, ( m, count[i], type,
+ indices[i] ));
}
}
}
diff --git a/mesalib/src/mesa/program/ir_to_mesa.cpp b/mesalib/src/mesa/program/ir_to_mesa.cpp
index 9919874a6..95987107f 100644
--- a/mesalib/src/mesa/program/ir_to_mesa.cpp
+++ b/mesalib/src/mesa/program/ir_to_mesa.cpp
@@ -2917,7 +2917,7 @@ get_mesa_program(struct gl_context *ctx,
set_branchtargets(&v, mesa_instructions, num_instructions);
- if (ctx->Shader.Flags & GLSL_DUMP) {
+ if (ctx->_Shader->Flags & GLSL_DUMP) {
fprintf(stderr, "\n");
fprintf(stderr, "GLSL IR for linked %s program %d:\n", target_string,
shader_program->Name);
@@ -2953,7 +2953,7 @@ get_mesa_program(struct gl_context *ctx,
_mesa_reference_program(ctx, &shader->Program, prog);
- if ((ctx->Shader.Flags & GLSL_NO_OPT) == 0) {
+ if ((ctx->_Shader->Flags & GLSL_NO_OPT) == 0) {
_mesa_optimize_program(ctx, prog);
}
@@ -3096,7 +3096,7 @@ _mesa_glsl_link_shader(struct gl_context *ctx, struct gl_shader_program *prog)
}
}
- if (ctx->Shader.Flags & GLSL_DUMP) {
+ if (ctx->_Shader->Flags & GLSL_DUMP) {
if (!prog->LinkStatus) {
fprintf(stderr, "GLSL shader program %d failed to link\n", prog->Name);
}
diff --git a/mesalib/src/mesa/state_tracker/st_atom_clip.c b/mesalib/src/mesa/state_tracker/st_atom_clip.c
index 274b36a62..f82c1332a 100644
--- a/mesalib/src/mesa/state_tracker/st_atom_clip.c
+++ b/mesalib/src/mesa/state_tracker/st_atom_clip.c
@@ -52,7 +52,7 @@ static void update_clip( struct st_context *st )
/* if we have a vertex shader that writes clip vertex we need to pass
the pre-projection transformed coordinates into the driver. */
if (st->vp) {
- if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX])
+ if (ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX])
use_eye = TRUE;
}
diff --git a/mesalib/src/mesa/state_tracker/st_atom_constbuf.c b/mesalib/src/mesa/state_tracker/st_atom_constbuf.c
index a5013ed2c..7984bf742 100644
--- a/mesalib/src/mesa/state_tracker/st_atom_constbuf.c
+++ b/mesalib/src/mesa/state_tracker/st_atom_constbuf.c
@@ -219,7 +219,7 @@ static void st_bind_ubos(struct st_context *st,
static void bind_vs_ubos(struct st_context *st)
{
struct gl_shader_program *prog =
- st->ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
+ st->ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX];
if (!prog)
return;
@@ -239,7 +239,7 @@ const struct st_tracked_state st_bind_vs_ubos = {
static void bind_fs_ubos(struct st_context *st)
{
struct gl_shader_program *prog =
- st->ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT];
+ st->ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT];
if (!prog)
return;
@@ -259,7 +259,7 @@ const struct st_tracked_state st_bind_fs_ubos = {
static void bind_gs_ubos(struct st_context *st)
{
struct gl_shader_program *prog =
- st->ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
+ st->ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY];
if (!prog)
return;
diff --git a/mesalib/src/mesa/state_tracker/st_atom_texture.c b/mesalib/src/mesa/state_tracker/st_atom_texture.c
index 75e6face4..c9bffce4f 100644
--- a/mesalib/src/mesa/state_tracker/st_atom_texture.c
+++ b/mesalib/src/mesa/state_tracker/st_atom_texture.c
@@ -50,91 +50,165 @@
/**
- * Combine depth texture mode with "swizzle" so that depth mode swizzling
- * takes place before texture swizzling, and return the resulting swizzle.
- * If the format is not a depth format, return "swizzle" unchanged.
- *
- * \param format PIPE_FORMAT_*.
- * \param swizzle Texture swizzle, a bitmask computed using MAKE_SWIZZLE4.
- * \param depthmode One of GL_LUMINANCE, GL_INTENSITY, GL_ALPHA, GL_RED.
+ * Return swizzle1(swizzle2)
*/
-static GLuint
-apply_depthmode(enum pipe_format format, GLuint swizzle, GLenum depthmode)
+static unsigned
+swizzle_swizzle(unsigned swizzle1, unsigned swizzle2)
{
- const struct util_format_description *desc =
- util_format_description(format);
- unsigned char swiz[4];
- unsigned i;
-
- if (desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS ||
- desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_NONE) {
- /* Not a depth format. */
- return swizzle;
+ unsigned i, swz[4];
+
+ for (i = 0; i < 4; i++) {
+ unsigned s = GET_SWZ(swizzle1, i);
+ switch (s) {
+ case SWIZZLE_X:
+ case SWIZZLE_Y:
+ case SWIZZLE_Z:
+ case SWIZZLE_W:
+ swz[i] = GET_SWZ(swizzle2, s);
+ break;
+ case SWIZZLE_ZERO:
+ swz[i] = SWIZZLE_ZERO;
+ break;
+ case SWIZZLE_ONE:
+ swz[i] = SWIZZLE_ONE;
+ break;
+ default:
+ assert(!"Bad swizzle term");
+ swz[i] = SWIZZLE_X;
+ }
}
- for (i = 0; i < 4; i++)
- swiz[i] = GET_SWZ(swizzle, i);
+ return MAKE_SWIZZLE4(swz[0], swz[1], swz[2], swz[3]);
+}
- switch (depthmode) {
- case GL_LUMINANCE:
- /* Rewrite reads from W to ONE, and reads from XYZ to XXX. */
- for (i = 0; i < 4; i++)
- if (swiz[i] == SWIZZLE_W)
- swiz[i] = SWIZZLE_ONE;
- else if (swiz[i] < SWIZZLE_W)
- swiz[i] = SWIZZLE_X;
- break;
+/**
+ * Given a user-specified texture base format, the actual gallium texture
+ * format and the current GL_DEPTH_MODE, return a texture swizzle.
+ *
+ * Consider the case where the user requests a GL_RGB internal texture
+ * format the driver actually uses an RGBA format. The A component should
+ * be ignored and sampling from the texture should always return (r,g,b,1).
+ * But if we rendered to the texture we might have written A values != 1.
+ * By sampling the texture with a ".xyz1" swizzle we'll get the expected A=1.
+ * This function computes the texture swizzle needed to get the expected
+ * values.
+ *
+ * In the case of depth textures, the GL_DEPTH_MODE state determines the
+ * texture swizzle.
+ *
+ * This result must be composed with the user-specified swizzle to get
+ * the final swizzle.
+ */
+static unsigned
+compute_texture_format_swizzle(GLenum baseFormat, GLenum depthMode,
+ enum pipe_format actualFormat)
+{
+ switch (baseFormat) {
+ case GL_RGBA:
+ return SWIZZLE_XYZW;
+ case GL_RGB:
+ if (util_format_has_alpha(actualFormat))
+ return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_ONE);
+ else
+ return SWIZZLE_XYZW;
+ case GL_RG:
+ if (util_format_get_nr_components(actualFormat) > 2)
+ return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_ZERO, SWIZZLE_ONE);
+ else
+ return SWIZZLE_XYZW;
+ case GL_RED:
+ if (util_format_get_nr_components(actualFormat) > 1)
+ return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_ZERO,
+ SWIZZLE_ZERO, SWIZZLE_ONE);
+ else
+ return SWIZZLE_XYZW;
+ case GL_ALPHA:
+ if (util_format_get_nr_components(actualFormat) > 1)
+ return MAKE_SWIZZLE4(SWIZZLE_ZERO, SWIZZLE_ZERO,
+ SWIZZLE_ZERO, SWIZZLE_W);
+ else
+ return SWIZZLE_XYZW;
+ case GL_LUMINANCE:
+ if (util_format_get_nr_components(actualFormat) > 1)
+ return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_ONE);
+ else
+ return SWIZZLE_XYZW;
+ case GL_LUMINANCE_ALPHA:
+ if (util_format_get_nr_components(actualFormat) > 2)
+ return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_W);
+ else
+ return SWIZZLE_XYZW;
+ case GL_INTENSITY:
+ if (util_format_get_nr_components(actualFormat) > 1)
+ return SWIZZLE_XXXX;
+ else
+ return SWIZZLE_XYZW;
+ case GL_STENCIL_INDEX:
+ return SWIZZLE_XYZW;
+ case GL_DEPTH_STENCIL:
+ /* fall-through */
+ case GL_DEPTH_COMPONENT:
+ /* Now examine the depth mode */
+ switch (depthMode) {
+ case GL_LUMINANCE:
+ return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_ONE);
case GL_INTENSITY:
- /* Rewrite reads from XYZW to XXXX. */
- for (i = 0; i < 4; i++)
- if (swiz[i] <= SWIZZLE_W)
- swiz[i] = SWIZZLE_X;
- break;
-
+ return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X);
case GL_ALPHA:
- /* Rewrite reads from W to X, and reads from XYZ to 000. */
- for (i = 0; i < 4; i++)
- if (swiz[i] == SWIZZLE_W)
- swiz[i] = SWIZZLE_X;
- else if (swiz[i] < SWIZZLE_W)
- swiz[i] = SWIZZLE_ZERO;
- break;
+ return MAKE_SWIZZLE4(SWIZZLE_ZERO, SWIZZLE_ZERO,
+ SWIZZLE_ZERO, SWIZZLE_X);
case GL_RED:
- /* Rewrite reads W to 1, XYZ to X00 */
- for (i = 0; i < 4; i++)
- if (swiz[i] == SWIZZLE_W)
- swiz[i] = SWIZZLE_ONE;
- else if (swiz[i] == SWIZZLE_Y || swiz[i] == SWIZZLE_Z)
- swiz[i] = SWIZZLE_ZERO;
- break;
+ return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_ZERO,
+ SWIZZLE_ZERO, SWIZZLE_ONE);
+ default:
+ assert(!"Unexpected depthMode");
+ return SWIZZLE_XYZW;
+ }
+ default:
+ assert(!"Unexpected baseFormat");
+ return SWIZZLE_XYZW;
}
-
- return MAKE_SWIZZLE4(swiz[0], swiz[1], swiz[2], swiz[3]);
}
+static unsigned
+get_texture_format_swizzle(const struct st_texture_object *stObj)
+{
+ const struct gl_texture_image *texImage =
+ stObj->base.Image[0][stObj->base.BaseLevel];
+ unsigned tex_swizzle;
+
+ if (texImage) {
+ tex_swizzle = compute_texture_format_swizzle(texImage->_BaseFormat,
+ stObj->base.DepthMode,
+ stObj->pt->format);
+ }
+ else {
+ tex_swizzle = SWIZZLE_XYZW;
+ }
+
+ /* Combine the texture format swizzle with user's swizzle */
+ return swizzle_swizzle(stObj->base._Swizzle, tex_swizzle);
+}
+
+
/**
- * Return TRUE if the swizzling described by "swizzle" and
- * "depthmode" (for depth textures only) is different from the swizzling
- * set in the given sampler view.
+ * Return TRUE if the texture's sampler view swizzle is equal to
+ * the texture's swizzle.
*
- * \param sv A sampler view.
- * \param swizzle Texture swizzle, a bitmask computed using MAKE_SWIZZLE4.
- * \param depthmode One of GL_LUMINANCE, GL_INTENSITY, GL_ALPHA.
+ * \param stObj the st texture object,
*/
static boolean
-check_sampler_swizzle(struct pipe_sampler_view *sv,
- GLuint swizzle, GLenum depthmode)
+check_sampler_swizzle(const struct st_texture_object *stObj)
{
- swizzle = apply_depthmode(sv->texture->format, swizzle, depthmode);
-
- if ((sv->swizzle_r != GET_SWZ(swizzle, 0)) ||
- (sv->swizzle_g != GET_SWZ(swizzle, 1)) ||
- (sv->swizzle_b != GET_SWZ(swizzle, 2)) ||
- (sv->swizzle_a != GET_SWZ(swizzle, 3)))
- return TRUE;
- return FALSE;
+ const struct pipe_sampler_view *sv = stObj->sampler_view;
+ unsigned swizzle = get_texture_format_swizzle(stObj);
+
+ return ((sv->swizzle_r != GET_SWZ(swizzle, 0)) ||
+ (sv->swizzle_g != GET_SWZ(swizzle, 1)) ||
+ (sv->swizzle_b != GET_SWZ(swizzle, 2)) ||
+ (sv->swizzle_a != GET_SWZ(swizzle, 3)));
}
@@ -145,9 +219,7 @@ st_create_texture_sampler_view_from_stobj(struct pipe_context *pipe,
enum pipe_format format)
{
struct pipe_sampler_view templ;
- GLuint swizzle = apply_depthmode(stObj->pt->format,
- stObj->base._Swizzle,
- stObj->base.DepthMode);
+ unsigned swizzle = get_texture_format_swizzle(stObj);
u_sampler_view_default_template(&templ,
stObj->pt,
@@ -260,9 +332,7 @@ update_single_texture(struct st_context *st,
/* if sampler view has changed dereference it */
if (stObj->sampler_view) {
- if (check_sampler_swizzle(stObj->sampler_view,
- stObj->base._Swizzle,
- stObj->base.DepthMode) ||
+ if (check_sampler_swizzle(stObj) ||
(view_format != stObj->sampler_view->format) ||
stObj->base.BaseLevel != stObj->sampler_view->u.tex.first_level) {
pipe_sampler_view_release(pipe, &stObj->sampler_view);
diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
index 2b3636151..6119cc275 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -1364,7 +1364,7 @@ blit_copy_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
!ctx->Stencil.Enabled &&
!ctx->FragmentProgram.Enabled &&
!ctx->VertexProgram.Enabled &&
- !ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT] &&
+ !ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT] &&
ctx->DrawBuffer->_NumColorDrawBuffers == 1 &&
!ctx->Query.CondRenderQuery &&
!ctx->Query.CurrentOcclusionObject) {
diff --git a/mesalib/src/mesa/state_tracker/st_cb_queryobj.c b/mesalib/src/mesa/state_tracker/st_cb_queryobj.c
index 5186a5157..78a737094 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_queryobj.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_queryobj.c
@@ -141,7 +141,13 @@ st_BeginQuery(struct gl_context *ctx, struct gl_query_object *q)
stq->pq = pipe->create_query(pipe, type);
stq->type = type;
}
- pipe->begin_query(pipe, stq->pq);
+ if (stq->pq) {
+ pipe->begin_query(pipe, stq->pq);
+ }
+ else {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQuery");
+ return;
+ }
}
assert(stq->type == type);
}
@@ -162,7 +168,8 @@ st_EndQuery(struct gl_context *ctx, struct gl_query_object *q)
stq->type = PIPE_QUERY_TIMESTAMP;
}
- pipe->end_query(pipe, stq->pq);
+ if (stq->pq)
+ pipe->end_query(pipe, stq->pq);
}
@@ -171,6 +178,13 @@ get_query_result(struct pipe_context *pipe,
struct st_query_object *stq,
boolean wait)
{
+ if (!stq->pq) {
+ /* Only needed in case we failed to allocate the gallium query earlier.
+ * Return TRUE so we don't spin on this forever.
+ */
+ return TRUE;
+ }
+
if (!pipe->get_query_result(pipe,
stq->pq,
wait,
diff --git a/mesalib/src/mesa/state_tracker/st_context.c b/mesalib/src/mesa/state_tracker/st_context.c
index 0ffc76263..807a86fdf 100644
--- a/mesalib/src/mesa/state_tracker/st_context.c
+++ b/mesalib/src/mesa/state_tracker/st_context.c
@@ -33,6 +33,7 @@
#include "main/shaderobj.h"
#include "main/version.h"
#include "main/vtxfmt.h"
+#include "main/hash.h"
#include "program/prog_cache.h"
#include "vbo/vbo.h"
#include "glapi/glapi.h"
@@ -66,6 +67,7 @@
#include "st_gen_mipmap.h"
#include "st_program.h"
#include "st_vdpau.h"
+#include "st_texture.h"
#include "pipe/p_context.h"
#include "util/u_inlines.h"
#include "util/u_upload_mgr.h"
@@ -280,6 +282,19 @@ static void st_destroy_context_priv( struct st_context *st )
free( st );
}
+
+/**
+ * Callback to release the sampler view attached to a texture object.
+ * Called by _mesa_HashWalk().
+ */
+static void
+destroy_tex_sampler_cb(GLuint id, void *data, void *userData)
+{
+ struct gl_texture_object *texObj = (struct gl_texture_object *) data;
+ struct st_context *st = (struct st_context *) userData;
+
+ st_texture_release_sampler_view(st, st_texture_object(texObj));
+}
void st_destroy_context( struct st_context *st )
{
@@ -288,6 +303,8 @@ void st_destroy_context( struct st_context *st )
struct gl_context *ctx = st->ctx;
GLuint i;
+ _mesa_HashWalk(ctx->Shared->TexObjects, destroy_tex_sampler_cb, st);
+
/* need to unbind and destroy CSO objects before anything else */
cso_release_all(st->cso_context);
diff --git a/mesalib/src/mesa/state_tracker/st_draw.c b/mesalib/src/mesa/state_tracker/st_draw.c
index dba5870a0..c8189faad 100644
--- a/mesalib/src/mesa/state_tracker/st_draw.c
+++ b/mesalib/src/mesa/state_tracker/st_draw.c
@@ -131,7 +131,7 @@ setup_index_buffer(struct st_context *st,
static void
check_uniforms(struct gl_context *ctx)
{
- struct gl_shader_program **shProg = ctx->Shader.CurrentProgram;
+ struct gl_shader_program **shProg = ctx->_Shader->CurrentProgram;
unsigned j;
for (j = 0; j < 3; j++) {
diff --git a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
index a9e75d8a6..f019a55c2 100644
--- a/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
+++ b/mesalib/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
@@ -5198,7 +5198,7 @@ get_mesa_program(struct gl_context *ctx,
/* Write the END instruction. */
v->emit(NULL, TGSI_OPCODE_END);
- if (ctx->Shader.Flags & GLSL_DUMP) {
+ if (ctx->_Shader->Flags & GLSL_DUMP) {
printf("\n");
printf("GLSL IR for linked %s program %d:\n",
_mesa_shader_stage_to_string(shader->Stage),
diff --git a/mesalib/src/mesa/state_tracker/st_program.c b/mesalib/src/mesa/state_tracker/st_program.c
index 692a57008..2f0ec32f5 100644
--- a/mesalib/src/mesa/state_tracker/st_program.c
+++ b/mesalib/src/mesa/state_tracker/st_program.c
@@ -1204,7 +1204,7 @@ st_get_gp_variant(struct st_context *st,
void
st_print_shaders(struct gl_context *ctx)
{
- struct gl_shader_program **shProg = ctx->Shader.CurrentProgram;
+ struct gl_shader_program **shProg = ctx->_Shader->CurrentProgram;
unsigned j;
for (j = 0; j < 3; j++) {
diff --git a/mesalib/src/mesa/state_tracker/st_texture.c b/mesalib/src/mesa/state_tracker/st_texture.c
index b5ccc76d4..a3b345356 100644
--- a/mesalib/src/mesa/state_tracker/st_texture.c
+++ b/mesalib/src/mesa/state_tracker/st_texture.c
@@ -412,3 +412,10 @@ st_create_color_map_texture(struct gl_context *ctx)
return pt;
}
+void
+st_texture_release_sampler_view(struct st_context *st,
+ struct st_texture_object *stObj)
+{
+ if (stObj->sampler_view && stObj->sampler_view->context == st->pipe)
+ pipe_sampler_view_reference(&stObj->sampler_view, NULL);
+}
diff --git a/mesalib/src/mesa/state_tracker/st_texture.h b/mesalib/src/mesa/state_tracker/st_texture.h
index bce2a0934..b4a27a00a 100644
--- a/mesalib/src/mesa/state_tracker/st_texture.h
+++ b/mesalib/src/mesa/state_tracker/st_texture.h
@@ -227,4 +227,8 @@ st_texture_image_copy(struct pipe_context *pipe,
extern struct pipe_resource *
st_create_color_map_texture(struct gl_context *ctx);
+extern void
+st_texture_release_sampler_view(struct st_context *st,
+ struct st_texture_object *stObj);
+
#endif
diff --git a/mesalib/src/mesa/swrast/s_fragprog.c b/mesalib/src/mesa/swrast/s_fragprog.c
index fa45fa97a..21699f3ea 100644
--- a/mesalib/src/mesa/swrast/s_fragprog.c
+++ b/mesalib/src/mesa/swrast/s_fragprog.c
@@ -182,7 +182,7 @@ init_machine(struct gl_context *ctx, struct gl_program_machine *machine,
machine->Samplers = program->Base.SamplerUnits;
/* if running a GLSL program (not ARB_fragment_program) */
- if (ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT]) {
+ if (ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT]) {
/* Store front/back facing value */
machine->Attribs[VARYING_SLOT_FACE][col][0] = 1.0F - span->facing;
}
diff --git a/xorg-server/dix/gc.c b/xorg-server/dix/gc.c
index efe6d6090..88d650121 100644
--- a/xorg-server/dix/gc.c
+++ b/xorg-server/dix/gc.c
@@ -261,12 +261,14 @@ ChangeGC(ClientPtr client, GC * pGC, BITS32 mask, ChangeGCValPtr pUnion)
case GCStipple:
NEXT_PTR(PixmapPtr, pPixmap);
- if ((pPixmap->drawable.depth != 1) ||
- (pPixmap->drawable.pScreen != pGC->pScreen)) {
+ if (pPixmap && ((pPixmap->drawable.depth != 1) ||
+ (pPixmap->drawable.pScreen != pGC->pScreen)))
+ {
error = BadMatch;
}
else {
- pPixmap->refcnt++;
+ if (pPixmap)
+ pPixmap->refcnt++;
if (pGC->stipple)
(*pGC->pScreen->DestroyPixmap) (pGC->stipple);
pGC->stipple = pPixmap;
diff --git a/xorg-server/fb/fbblt.c b/xorg-server/fb/fbblt.c
index 72a05f61a..c615106d1 100644
--- a/xorg-server/fb/fbblt.c
+++ b/xorg-server/fb/fbblt.c
@@ -56,42 +56,48 @@ fbBlt(FbBits * srcLine,
int n, nmiddle;
Bool destInvarient;
int startbyte, endbyte;
- int careful;
FbDeclareMergeRop();
+ if (alu == GXcopy && pm == FB_ALLONES &&
+ !(srcX & 7) && !(dstX & 7) && !(width & 7))
+ {
+ CARD8 *src_byte = (CARD8 *) srcLine + (srcX >> 3);
+ CARD8 *dst_byte = (CARD8 *) dstLine + (dstX >> 3);
+ FbStride src_byte_stride = srcStride << (FB_SHIFT - 3);
+ FbStride dst_byte_stride = dstStride << (FB_SHIFT - 3);
+ int width_byte = (width >> 3);
+
+ /* Make sure there's no overlap; we can't use memcpy in that
+ * case as it's not well defined, so fall through to the
+ * general code
+ */
+ if (src_byte + width_byte <= dst_byte ||
+ dst_byte + width_byte <= src_byte)
+ {
+ int i;
+
+ if (!upsidedown)
+ for (i = 0; i < height; i++)
+ MEMCPY_WRAPPED(dst_byte + i * dst_byte_stride,
+ src_byte + i * src_byte_stride,
+ width_byte);
+ else
+ for (i = height - 1; i >= 0; i--)
+ MEMCPY_WRAPPED(dst_byte + i * dst_byte_stride,
+ src_byte + i * src_byte_stride,
+ width_byte);
+
+ return;
+ }
+ }
+
if (bpp == 24 && !FbCheck24Pix(pm)) {
fbBlt24(srcLine, srcStride, srcX, dstLine, dstStride, dstX,
width, height, alu, pm, reverse, upsidedown);
return;
}
- careful = !((srcLine < dstLine && srcLine + width * (bpp >> 3) > dstLine) ||
- (dstLine < srcLine && dstLine + width * (bpp >> 3) > srcLine))
- || (bpp & 7);
-
- if (alu == GXcopy && pm == FB_ALLONES && !careful &&
- !(srcX & 7) && !(dstX & 7) && !(width & 7)) {
- int i;
- CARD8 *tmpsrc = (CARD8 *) srcLine;
- CARD8 *tmpdst = (CARD8 *) dstLine;
-
- srcStride *= sizeof(FbBits);
- dstStride *= sizeof(FbBits);
- width >>= 3;
- tmpsrc += (srcX >> 3);
- tmpdst += (dstX >> 3);
-
- if (!upsidedown)
- for (i = 0; i < height; i++)
- MEMCPY_WRAPPED(tmpdst + i * dstStride, tmpsrc + i * srcStride, width);
- else
- for (i = height - 1; i >= 0; i--)
- MEMCPY_WRAPPED(tmpdst + i * dstStride, tmpsrc + i * srcStride, width);
-
- return;
- }
-
FbInitializeMergeRop(alu, pm);
destInvarient = FbDestInvarientMergeRop();
if (upsidedown) {
diff --git a/xorg-server/glamor/Makefile.am b/xorg-server/glamor/Makefile.am
index ffc8c23d8..8555e4087 100644
--- a/xorg-server/glamor/Makefile.am
+++ b/xorg-server/glamor/Makefile.am
@@ -20,8 +20,11 @@ libglamor_la_SOURCES = \
glamor_polylines.c \
glamor_putimage.c \
glamor_setspans.c \
+ glamor_segment.c \
glamor_render.c \
glamor_gradient.c \
+ glamor_program.c \
+ glamor_transform.c \
glamor_trapezoid.c \
glamor_tile.c \
glamor_triangles.c\
@@ -29,7 +32,7 @@ libglamor_la_SOURCES = \
glamor_getimage.c\
glamor_copyplane.c\
glamor_glyphblt.c\
- glamor_polyops.c\
+ glamor_points.c\
glamor_priv.h\
glamor_pixmap.c\
glamor_largepixmap.c\
diff --git a/xorg-server/glamor/glamor.c b/xorg-server/glamor/glamor.c
index 0f7d68b70..30944326b 100644
--- a/xorg-server/glamor/glamor.c
+++ b/xorg-server/glamor/glamor.c
@@ -76,6 +76,10 @@ glamor_set_pixmap_type(PixmapPtr pixmap, glamor_pixmap_type_t type)
pixmap_priv->base.glamor_priv = glamor_priv;
}
pixmap_priv->type = type;
+ pixmap_priv->base.box.x1 = 0;
+ pixmap_priv->base.box.x2 = pixmap->drawable.width;
+ pixmap_priv->base.box.y1 = 0;
+ pixmap_priv->base.box.y2 = pixmap->drawable.height;
}
_X_EXPORT void
@@ -178,8 +182,14 @@ glamor_create_pixmap(ScreenPtr screen, int w, int h, int depth,
pitch = (((w * pixmap->drawable.bitsPerPixel + 7) / 8) + 3) & ~3;
screen->ModifyPixmapHeader(pixmap, w, h, 0, 0, pitch, NULL);
- if (type == GLAMOR_MEMORY_MAP || glamor_check_fbo_size(glamor_priv, w, h)) {
+ if (type == GLAMOR_MEMORY_MAP || usage == GLAMOR_CREATE_NO_LARGE ||
+ glamor_check_fbo_size(glamor_priv, w, h))
+ {
pixmap_priv->type = type;
+ pixmap_priv->base.box.x1 = 0;
+ pixmap_priv->base.box.y1 = 0;
+ pixmap_priv->base.box.x2 = w;
+ pixmap_priv->base.box.y2 = h;
fbo = glamor_create_fbo(glamor_priv, w, h, format, usage);
}
else {
@@ -341,7 +351,7 @@ glamor_init(ScreenPtr screen, unsigned int flags)
else
glamor_priv->gl_flavor = GLAMOR_GL_ES2;
- gl_version = glamor_gl_get_version();
+ gl_version = epoxy_gl_version();
/* We'd like to require GL_ARB_map_buffer_range or
* GL_OES_map_buffer_range, since it offers more information to
@@ -357,29 +367,31 @@ glamor_init(ScreenPtr screen, unsigned int flags)
* Windows with Intel 4-series (G45) graphics or older.
*/
if (glamor_priv->gl_flavor == GLAMOR_GL_DESKTOP) {
- if (gl_version < GLAMOR_GL_VERSION_ENCODE(1, 3)) {
- ErrorF("Require OpenGL version 1.3 or later.\n");
+ if (gl_version < 21) {
+ ErrorF("Require OpenGL version 2.1 or later.\n");
goto fail;
}
} else {
- if (gl_version < GLAMOR_GL_VERSION_ENCODE(2, 0)) {
+ if (gl_version < 20) {
ErrorF("Require Open GLES2.0 or later.\n");
goto fail;
}
- if (!glamor_gl_has_extension("GL_EXT_texture_format_BGRA8888")) {
+ if (!epoxy_has_gl_extension("GL_EXT_texture_format_BGRA8888")) {
ErrorF("GL_EXT_texture_format_BGRA8888 required\n");
goto fail;
}
}
- glamor_priv->has_khr_debug = glamor_gl_has_extension("GL_KHR_debug");
+ glamor_priv->has_khr_debug = epoxy_has_gl_extension("GL_KHR_debug");
glamor_priv->has_pack_invert =
- glamor_gl_has_extension("GL_MESA_pack_invert");
+ epoxy_has_gl_extension("GL_MESA_pack_invert");
glamor_priv->has_fbo_blit =
- glamor_gl_has_extension("GL_EXT_framebuffer_blit");
+ epoxy_has_gl_extension("GL_EXT_framebuffer_blit");
+ glamor_priv->has_map_buffer_range =
+ epoxy_has_gl_extension("GL_ARB_map_buffer_range");
glamor_priv->has_buffer_storage =
- glamor_gl_has_extension("GL_ARB_buffer_storage");
+ epoxy_has_gl_extension("GL_ARB_buffer_storage");
glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &glamor_priv->max_fbo_size);
#ifdef MAX_FBO_SIZE
glamor_priv->max_fbo_size = MAX_FBO_SIZE;
diff --git a/xorg-server/glamor/glamor.h b/xorg-server/glamor/glamor.h
index d05d2f4ea..11ec49361 100644
--- a/xorg-server/glamor/glamor.h
+++ b/xorg-server/glamor/glamor.h
@@ -140,9 +140,16 @@ extern _X_EXPORT void glamor_set_pixmap_type(PixmapPtr pixmap,
glamor_pixmap_type_t type);
extern _X_EXPORT void glamor_destroy_textured_pixmap(PixmapPtr pixmap);
extern _X_EXPORT void glamor_block_handler(ScreenPtr screen);
+
extern _X_EXPORT PixmapPtr glamor_create_pixmap(ScreenPtr screen, int w, int h,
int depth, unsigned int usage);
+#define GLAMOR_CREATE_PIXMAP_CPU 0x100
+#define GLAMOR_CREATE_PIXMAP_FIXUP 0x101
+#define GLAMOR_CREATE_FBO_NO_FBO 0x103
+#define GLAMOR_CREATE_PIXMAP_MAP 0x104
+#define GLAMOR_CREATE_NO_LARGE 0x105
+
/* @glamor_egl_exchange_buffers: Exchange the underlying buffers(KHR image,fbo).
*
* @front: front pixmap.
diff --git a/xorg-server/glamor/glamor_core.c b/xorg-server/glamor/glamor_core.c
index 6c0b3c834..5711be72f 100644
--- a/xorg-server/glamor/glamor_core.c
+++ b/xorg-server/glamor/glamor_core.c
@@ -559,48 +559,3 @@ glamor_bitmap_to_region(PixmapPtr pixmap)
return ret;
}
-/* Borrow from cairo. */
-Bool
-glamor_gl_has_extension(const char *extension)
-{
- const char *pext;
- int ext_len;
-
- ext_len = strlen(extension);
-
- pext = (const char *) glGetString(GL_EXTENSIONS);
-
- if (pext == NULL || extension == NULL)
- return FALSE;
-
- while ((pext = strstr(pext, extension)) != NULL) {
- if (pext[ext_len] == ' ' || pext[ext_len] == '\0')
- return TRUE;
- pext += ext_len;
- }
- return FALSE;
-}
-
-int
-glamor_gl_get_version(void)
-{
- int major, minor;
- const char *version = (const char *) glGetString(GL_VERSION);
- const char *dot = version == NULL ? NULL : strchr(version, '.');
- const char *major_start = dot;
-
- /* Sanity check */
- if (dot == NULL || dot == version || *(dot + 1) == '\0') {
- major = 0;
- minor = 0;
- }
- else {
- /* Find the start of the major version in the string */
- while (major_start > version && *major_start != ' ')
- --major_start;
- major = strtol(major_start, NULL, 10);
- minor = strtol(dot + 1, NULL, 10);
- }
-
- return GLAMOR_GL_VERSION_ENCODE(major, minor);
-}
diff --git a/xorg-server/glamor/glamor_fbo.c b/xorg-server/glamor/glamor_fbo.c
index 640b6fd81..4f6da67fb 100644
--- a/xorg-server/glamor/glamor_fbo.c
+++ b/xorg-server/glamor/glamor_fbo.c
@@ -361,9 +361,6 @@ glamor_create_fbo(glamor_screen_private *glamor_priv,
GLint tex = 0;
int cache_flag;
- if (!glamor_check_fbo_size(glamor_priv, w, h))
- return NULL;
-
if (flag == GLAMOR_CREATE_FBO_NO_FBO)
goto new_fbo;
diff --git a/xorg-server/glamor/glamor_fill.c b/xorg-server/glamor/glamor_fill.c
index 7461b62fa..2fa726e72 100644
--- a/xorg-server/glamor/glamor_fill.c
+++ b/xorg-server/glamor/glamor_fill.c
@@ -218,9 +218,6 @@ _glamor_solid_boxes(PixmapPtr pixmap, BoxPtr box, int nbox, float *color)
}
}
- if (_X_UNLIKELY(nbox > 1))
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, glamor_priv->ebo);
-
glVertexAttribPointer(GLAMOR_VERTEX_POS, 2, GL_FLOAT,
GL_FALSE, 2 * sizeof(float), vertices);
glEnableVertexAttribArray(GLAMOR_VERTEX_POS);
diff --git a/xorg-server/glamor/glamor_glyphs.c b/xorg-server/glamor/glamor_glyphs.c
index 2b2c735d4..a04ae8261 100644
--- a/xorg-server/glamor/glamor_glyphs.c
+++ b/xorg-server/glamor/glamor_glyphs.c
@@ -332,7 +332,7 @@ glamor_realize_glyph_caches(ScreenPtr pScreen)
pixmap = pScreen->CreatePixmap(pScreen,
CACHE_PICTURE_SIZE,
CACHE_PICTURE_SIZE + MASK_CACHE_MAX_SIZE,
- depth, 0);
+ depth, GLAMOR_CREATE_NO_LARGE);
if (!pixmap)
goto bail;
diff --git a/xorg-server/glamor/glamor_gradient.c b/xorg-server/glamor/glamor_gradient.c
index f77d6a8e3..c24f3427f 100644
--- a/xorg-server/glamor/glamor_gradient.c
+++ b/xorg-server/glamor/glamor_gradient.c
@@ -247,7 +247,6 @@ _glamor_create_radial_gradient_program(ScreenPtr screen, int stops_count,
"{\n"\
" float t = 0.0;\n"\
" float sqrt_value;\n"\
- " int revserse = 0;\n"\
" t_invalid = 0;\n"\
" \n"\
" vec3 tmp = vec3(source_texture.x, source_texture.y, 1.0);\n"\
@@ -295,30 +294,11 @@ _glamor_create_radial_gradient_program(ScreenPtr screen, int stops_count,
" }\n"\
" \n"\
" if(repeat_type == %d){\n" /* repeat normal*/\
- " while(t > 1.0) \n"\
- " t = t - 1.0; \n"\
- " while(t < 0.0) \n"\
- " t = t + 1.0; \n"\
+ " t = fract(t);\n"\
" }\n"\
" \n"\
" if(repeat_type == %d) {\n" /* repeat reflect*/\
- " while(t > 1.0) {\n"\
- " t = t - 1.0; \n"\
- " if(revserse == 0)\n"\
- " revserse = 1;\n"\
- " else\n"\
- " revserse = 0;\n"\
- " }\n"\
- " while(t < 0.0) {\n"\
- " t = t + 1.0; \n"\
- " if(revserse == 0)\n"\
- " revserse = 1;\n"\
- " else\n"\
- " revserse = 0;\n"\
- " }\n"\
- " if(revserse == 1) {\n"\
- " t = 1.0 - t; \n"\
- " }\n"\
+ " t = abs(fract(t * 0.5 + 0.5) * 2.0 - 1.0);\n"\
" }\n"\
" \n"\
" return t;\n"\
@@ -492,7 +472,6 @@ _glamor_create_linear_gradient_program(ScreenPtr screen, int stops_count,
" vec4 stop_color_before;\n"\
" vec4 stop_color_after;\n"\
" float new_alpha; \n"\
- " int revserse = 0;\n"\
" vec4 gradient_color;\n"\
" float percentage; \n"\
" vec3 source_texture_trans = transform_mat * tmp;\n"\
@@ -512,30 +491,11 @@ _glamor_create_linear_gradient_program(ScreenPtr screen, int stops_count,
" distance = distance - _p1_distance; \n"\
" \n"\
" if(repeat_type == %d){\n" /* repeat normal*/\
- " while(distance > _pt_distance) \n"\
- " distance = distance - (_pt_distance); \n"\
- " while(distance < 0.0) \n"\
- " distance = distance + (_pt_distance); \n"\
+ " distance = mod(distance, _pt_distance);\n"\
" }\n"\
" \n"\
" if(repeat_type == %d) {\n" /* repeat reflect*/\
- " while(distance > _pt_distance) {\n"\
- " distance = distance - (_pt_distance); \n"\
- " if(revserse == 0)\n"\
- " revserse = 1;\n"\
- " else\n"\
- " revserse = 0;\n"\
- " }\n"\
- " while(distance < 0.0) {\n"\
- " distance = distance + (_pt_distance); \n"\
- " if(revserse == 0)\n"\
- " revserse = 1;\n"\
- " else\n"\
- " revserse = 0;\n"\
- " }\n"\
- " if(revserse == 1) {\n"\
- " distance = (_pt_distance) - distance; \n"\
- " }\n"\
+ " distance = abs(mod(distance + _pt_distance, 2.0 * _pt_distance) - _pt_distance);\n"\
" }\n"\
" \n"\
" len_percentage = distance/(_pt_distance);\n"\
@@ -1160,9 +1120,6 @@ glamor_generate_radial_gradient_picture(ScreenPtr screen,
free(stop_colors);
}
- glBindBuffer(GL_ARRAY_BUFFER, 0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
@@ -1181,9 +1138,6 @@ glamor_generate_radial_gradient_picture(ScreenPtr screen,
free(stop_colors);
}
- glBindBuffer(GL_ARRAY_BUFFER, 0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
glamor_put_context(glamor_priv);
@@ -1511,9 +1465,6 @@ glamor_generate_linear_gradient_picture(ScreenPtr screen,
free(stop_colors);
}
- glBindBuffer(GL_ARRAY_BUFFER, 0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
@@ -1532,9 +1483,6 @@ glamor_generate_linear_gradient_picture(ScreenPtr screen,
free(stop_colors);
}
- glBindBuffer(GL_ARRAY_BUFFER, 0);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
glamor_put_context(glamor_priv);
diff --git a/xorg-server/glamor/glamor_largepixmap.c b/xorg-server/glamor/glamor_largepixmap.c
index b8c064038..b3a8d5d20 100644
--- a/xorg-server/glamor/glamor_largepixmap.c
+++ b/xorg-server/glamor/glamor_largepixmap.c
@@ -1015,7 +1015,6 @@ glamor_composite_largepixmap_region(CARD8 op,
INT16 x_dest, INT16 y_dest,
CARD16 width, CARD16 height)
{
- glamor_screen_private *glamor_priv;
glamor_pixmap_clipped_regions *clipped_dest_regions;
glamor_pixmap_clipped_regions *clipped_source_regions;
glamor_pixmap_clipped_regions *clipped_mask_regions;
@@ -1044,9 +1043,8 @@ glamor_composite_largepixmap_region(CARD8 op,
else
mask_repeat_type = RepeatNone;
- glamor_priv = dest_pixmap_priv->base.glamor_priv;
- fixed_block_width = glamor_priv->max_fbo_size;
- fixed_block_height = glamor_priv->max_fbo_size;
+ fixed_block_width = dest_pixmap_priv->large.block_w;
+ fixed_block_height = dest_pixmap_priv->large.block_h;
/* If we got an totally out-of-box region for a source or mask
* region without repeat, we need to set it as null_source and
* give it a solid color (0,0,0,0). */
@@ -1112,8 +1110,8 @@ glamor_composite_largepixmap_region(CARD8 op,
/*compute the correct block width and height whose transformed source/mask
*region can fit into one texture.*/
- if (force_clip || fixed_block_width < glamor_priv->max_fbo_size
- || fixed_block_height < glamor_priv->max_fbo_size)
+ if (force_clip || fixed_block_width < dest_pixmap_priv->large.block_w
+ || fixed_block_height < dest_pixmap_priv->large.block_h)
clipped_dest_regions =
glamor_compute_clipped_regions_ext(dest_pixmap_priv, region,
&n_dest_regions,
diff --git a/xorg-server/glamor/glamor_pixmap.c b/xorg-server/glamor/glamor_pixmap.c
index 615faad33..891ecdd37 100644
--- a/xorg-server/glamor/glamor_pixmap.c
+++ b/xorg-server/glamor/glamor_pixmap.c
@@ -1013,10 +1013,9 @@ glamor_upload_sub_pixmap_to_texture(PixmapPtr pixmap, int x, int y, int w,
clipped_regions =
glamor_compute_clipped_regions_ext(pixmap_priv, &region,
&n_region,
- pixmap_priv->base.
- glamor_priv->max_fbo_size,
- pixmap_priv->base.
- glamor_priv->max_fbo_size, 0,
+ pixmap_priv->large.block_w,
+ pixmap_priv->large.block_h,
+ 0,
0);
DEBUGF("prepare upload %dx%d to a large pixmap %p\n", w, h, pixmap);
for (i = 0; i < n_region; i++) {
@@ -1374,10 +1373,9 @@ glamor_download_sub_pixmap_to_cpu(PixmapPtr pixmap, int x, int y, int w, int h,
clipped_regions =
glamor_compute_clipped_regions_ext(pixmap_priv, &region,
&n_region,
- pixmap_priv->base.
- glamor_priv->max_fbo_size,
- pixmap_priv->base.
- glamor_priv->max_fbo_size, 0,
+ pixmap_priv->large.block_w,
+ pixmap_priv->large.block_h,
+ 0,
0);
DEBUGF("start download large pixmap %p %dx%d \n", pixmap, w, h);
diff --git a/xorg-server/glamor/glamor_points.c b/xorg-server/glamor/glamor_points.c
new file mode 100644
index 000000000..5399f96e8
--- /dev/null
+++ b/xorg-server/glamor/glamor_points.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright © 2009 Intel Corporation
+ * Copyright © 1998 Keith Packard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * Authors:
+ * Zhigang Gong <zhigang.gong@linux.intel.com>
+ *
+ */
+
+#include "glamor_priv.h"
+#include "glamor_transform.h"
+
+static const glamor_facet glamor_facet_point = {
+ .name = "poly_point",
+ .vs_vars = "attribute vec2 primitive;\n",
+ .vs_exec = GLAMOR_POS(gl_Position, primitive),
+};
+
+Bool
+glamor_poly_point_nf(DrawablePtr drawable, GCPtr gc, int mode, int npt, DDXPointPtr ppt)
+{
+ ScreenPtr screen = drawable->pScreen;
+ glamor_screen_private *glamor_priv = glamor_get_screen_private(screen);
+ PixmapPtr pixmap = glamor_get_drawable_pixmap(drawable);
+ glamor_program *prog = &glamor_priv->point_prog;
+ glamor_pixmap_private *pixmap_priv;
+ int off_x, off_y;
+ GLshort *vbo_ppt;
+ char *vbo_offset;
+ int box_x, box_y;
+
+ pixmap_priv = glamor_get_pixmap_private(pixmap);
+ if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv))
+ goto bail;
+
+ glamor_get_context(glamor_priv);
+
+ if (prog->failed)
+ goto bail_ctx;
+
+ if (!prog->prog) {
+ if (!glamor_build_program(screen, prog,
+ &glamor_facet_point,
+ &glamor_fill_solid))
+ goto bail_ctx;
+ }
+
+ if (!glamor_use_program(pixmap, gc, prog, NULL))
+ goto bail_ctx;
+
+ vbo_ppt = glamor_get_vbo_space(screen, npt * (2 * sizeof (INT16)), &vbo_offset);
+ glEnableVertexAttribArray(GLAMOR_VERTEX_POS);
+ glVertexAttribPointer(GLAMOR_VERTEX_POS, 2, GL_SHORT, GL_FALSE, 0, vbo_offset);
+ if (mode == CoordModePrevious) {
+ int n = npt;
+ INT16 x = 0, y = 0;
+ while (n--) {
+ vbo_ppt[0] = (x += ppt->x);
+ vbo_ppt[1] = (y += ppt->y);
+ vbo_ppt += 2;
+ ppt++;
+ }
+ } else
+ memcpy(vbo_ppt, ppt, npt * (2 * sizeof (INT16)));
+ glamor_put_vbo_space(screen);
+
+ glEnable(GL_SCISSOR_TEST);
+
+ glamor_pixmap_loop(pixmap_priv, box_x, box_y) {
+ int nbox = RegionNumRects(gc->pCompositeClip);
+ BoxPtr box = RegionRects(gc->pCompositeClip);
+
+ glamor_set_destination_drawable(drawable, box_x, box_y, TRUE, TRUE, prog->matrix_uniform, &off_x, &off_y);
+
+ while (nbox--) {
+ glScissor(box->x1 + off_x,
+ box->y1 + off_y,
+ box->x2 - box->x1,
+ box->y2 - box->y1);
+ box++;
+ glDrawArrays(GL_POINTS, 0, npt);
+ }
+ }
+
+ glDisable(GL_SCISSOR_TEST);
+ glDisable(GL_COLOR_LOGIC_OP);
+ glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
+
+ glamor_put_context(glamor_priv);
+
+ glamor_priv->state = RENDER_STATE;
+ glamor_priv->render_idle_cnt = 0;
+
+ return TRUE;
+
+bail_ctx:
+ glDisable(GL_COLOR_LOGIC_OP);
+ glamor_put_context(glamor_priv);
+bail:
+ return FALSE;
+}
+
+void
+glamor_poly_point(DrawablePtr drawable, GCPtr gc, int mode, int npt,
+ DDXPointPtr ppt)
+{
+ if (glamor_poly_point_nf(drawable, gc, mode, npt, ppt))
+ return;
+ miPolyPoint(drawable, gc, mode, npt, ppt);
+}
diff --git a/xorg-server/glamor/glamor_polyops.c b/xorg-server/glamor/glamor_polyops.c
deleted file mode 100644
index 1484d80f1..000000000
--- a/xorg-server/glamor/glamor_polyops.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright © 2009 Intel Corporation
- * Copyright © 1998 Keith Packard
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- *
- * Authors:
- * Zhigang Gong <zhigang.gong@linux.intel.com>
- *
- */
-
-#include "glamor_priv.h"
-
-static Bool
-_glamor_poly_point(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
- DDXPointPtr ppt, Bool fallback)
-{
- if (!fallback && glamor_ddx_fallback_check_gc(pGC)
- && glamor_ddx_fallback_check_pixmap(pDrawable))
- return FALSE;
-
- miPolyPoint(pDrawable, pGC, mode, npt, ppt);
-
- return TRUE;
-}
-
-void
-glamor_poly_point(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
- DDXPointPtr ppt)
-{
- _glamor_poly_point(pDrawable, pGC, mode, npt, ppt, TRUE);
-}
-
-Bool
-glamor_poly_point_nf(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
- DDXPointPtr ppt)
-{
- return _glamor_poly_point(pDrawable, pGC, mode, npt, ppt, FALSE);
-}
-
-static Bool
-_glamor_poly_segment(DrawablePtr pDrawable, GCPtr pGC, int nseg,
- xSegment *pSeg, Bool fallback)
-{
- if (!fallback && glamor_ddx_fallback_check_gc(pGC)
- && glamor_ddx_fallback_check_pixmap(pDrawable))
- return FALSE;
-
- miPolySegment(pDrawable, pGC, nseg, pSeg);
-
- return TRUE;
-}
-
-void
-glamor_poly_segment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSeg)
-{
- _glamor_poly_segment(pDrawable, pGC, nseg, pSeg, TRUE);
-}
-
-Bool
-glamor_poly_segment_nf(DrawablePtr pDrawable, GCPtr pGC, int nseg,
- xSegment *pSeg)
-{
- return _glamor_poly_segment(pDrawable, pGC, nseg, pSeg, FALSE);
-}
diff --git a/xorg-server/glamor/glamor_priv.h b/xorg-server/glamor/glamor_priv.h
index bc7d3f827..4c305abfc 100644
--- a/xorg-server/glamor/glamor_priv.h
+++ b/xorg-server/glamor/glamor_priv.h
@@ -52,6 +52,7 @@
#include "glamor_debug.h"
#include "glamor_context.h"
+#include "glamor_program.h"
#include <list.h>
@@ -153,13 +154,6 @@ enum glamor_gl_flavor {
GLAMOR_GL_ES2 // OPENGL ES2.0 API
};
-#define GLAMOR_CREATE_PIXMAP_CPU 0x100
-#define GLAMOR_CREATE_PIXMAP_FIXUP 0x101
-#define GLAMOR_CREATE_FBO_NO_FBO 0x103
-#define GLAMOR_CREATE_PIXMAP_MAP 0x104
-
-#define GLAMOR_CREATE_TEXTURE_EXACT_SIZE 0x104
-
#define GLAMOR_NUM_GLYPH_CACHE_FORMATS 2
#define GLAMOR_COMPOSITE_VBO_VERT_CNT (64*1024)
@@ -213,6 +207,7 @@ typedef struct glamor_screen_private {
enum glamor_gl_flavor gl_flavor;
int has_pack_invert;
int has_fbo_blit;
+ int has_map_buffer_range;
int has_buffer_storage;
int has_khr_debug;
int max_fbo_size;
@@ -225,6 +220,9 @@ typedef struct glamor_screen_private {
GLint solid_prog;
GLint solid_color_uniform_location;
+ /* glamor point shader */
+ glamor_program point_prog;
+
/* vertext/elment_index buffer object for render */
GLuint vbo, ebo;
/** Next offset within the VBO that glamor_get_vbo_space() will use. */
@@ -421,6 +419,7 @@ typedef struct glamor_pixmap_private_base {
unsigned char gl_tex:1;
glamor_pixmap_fbo *fbo;
PixmapPtr pixmap;
+ BoxRec box;
int drm_stride;
glamor_screen_private *glamor_priv;
PicturePtr picture;
@@ -476,6 +475,52 @@ typedef struct glamor_pixmap_private {
};
} glamor_pixmap_private;
+static inline glamor_pixmap_fbo *
+glamor_pixmap_fbo_at(glamor_pixmap_private *priv, int x, int y)
+{
+ if (priv->type == GLAMOR_TEXTURE_LARGE) {
+ assert(x < priv->large.block_wcnt);
+ assert(y < priv->large.block_hcnt);
+ return priv->large.fbo_array[y * priv->large.block_wcnt + x];
+ }
+ assert (x == 0);
+ assert (y == 0);
+ return priv->base.fbo;
+}
+
+static inline BoxPtr
+glamor_pixmap_box_at(glamor_pixmap_private *priv, int x, int y)
+{
+ if (priv->type == GLAMOR_TEXTURE_LARGE) {
+ assert(x < priv->large.block_wcnt);
+ assert(y < priv->large.block_hcnt);
+ return &priv->large.box_array[y * priv->large.block_wcnt + x];
+ }
+ assert (x == 0);
+ assert (y == 0);
+ return &priv->base.box;
+}
+
+static inline int
+glamor_pixmap_wcnt(glamor_pixmap_private *priv)
+{
+ if (priv->type == GLAMOR_TEXTURE_LARGE)
+ return priv->large.block_wcnt;
+ return 1;
+}
+
+static inline int
+glamor_pixmap_hcnt(glamor_pixmap_private *priv)
+{
+ if (priv->type == GLAMOR_TEXTURE_LARGE)
+ return priv->large.block_hcnt;
+ return 1;
+}
+
+#define glamor_pixmap_loop(priv, x, y) \
+ for (y = 0; y < glamor_pixmap_hcnt(priv); y++) \
+ for (x = 0; x < glamor_pixmap_wcnt(priv); x++)
+
/*
* Pixmap dynamic status, used by dynamic upload feature.
*
@@ -619,12 +664,6 @@ Bool glamor_set_alu(ScreenPtr screen, unsigned char alu);
Bool glamor_set_planemask(PixmapPtr pixmap, unsigned long planemask);
Bool glamor_change_window_attributes(WindowPtr pWin, unsigned long mask);
RegionPtr glamor_bitmap_to_region(PixmapPtr pixmap);
-Bool glamor_gl_has_extension(const char *extension);
-int glamor_gl_get_version(void);
-
-#define GLAMOR_GL_VERSION_ENCODE(major, minor) ( \
- ((major) * 256) \
- + ((minor) * 1))
/* glamor_fill.c */
Bool glamor_fill(DrawablePtr drawable,
diff --git a/xorg-server/glamor/glamor_program.c b/xorg-server/glamor/glamor_program.c
new file mode 100644
index 000000000..e2e1434ee
--- /dev/null
+++ b/xorg-server/glamor/glamor_program.c
@@ -0,0 +1,394 @@
+/*
+ * Copyright © 2014 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#include "glamor_priv.h"
+#include "glamor_transform.h"
+#include "glamor_program.h"
+
+static Bool
+use_solid(PixmapPtr pixmap, GCPtr gc, glamor_program *prog, void *arg)
+{
+ return glamor_set_solid(pixmap, gc, TRUE, prog->fg_uniform);
+}
+
+const glamor_facet glamor_fill_solid = {
+ .name = "solid",
+ .fs_exec = " gl_FragColor = fg;\n",
+ .locations = glamor_program_location_fg,
+ .use = use_solid,
+};
+
+static Bool
+use_tile(PixmapPtr pixmap, GCPtr gc, glamor_program *prog, void *arg)
+{
+ return glamor_set_tiled(pixmap, gc, prog->fill_offset_uniform, prog->fill_size_uniform);
+}
+
+static const glamor_facet glamor_fill_tile = {
+ .name = "tile",
+ .version = 130,
+ .vs_exec = " fill_pos = fill_offset + primitive.xy + pos;\n",
+ .fs_exec = " gl_FragColor = texelFetch(sampler, ivec2(mod(fill_pos,fill_size)), 0);\n",
+ .locations = glamor_program_location_fill,
+ .use = use_tile,
+};
+
+#if 0
+static Bool
+use_stipple(PixmapPtr pixmap, GCPtr gc, glamor_program *prog)
+{
+ return glamor_set_stippled(pixmap, gc, prog->fg_uniform, prog->fill_offset_uniform, prog->fill_size_uniform);
+}
+
+static const glamor_facet glamor_fill_stipple = {
+ .name = "stipple",
+ .version = 130,
+ .vs_exec = " fill_pos = fill_offset + primitive.xy + pos;\n";
+ .fs_exec = (" if (texelFetch(sampler, ivec2(mod(fill_pos,fill_size)), 0).x == 0)\n"
+ " discard;\n"
+ " gl_FragColor = fg;\n")
+ .locations = glamor_program_location_fg | glamor_program_location_fill
+ .use = use_stipple,
+};
+
+static const glamor_facet glamor_fill_opaque_stipple = {
+ .name = "opaque_stipple",
+ .version = 130,
+ .vs_exec = " fill_pos = fill_offset + primitive.xy + pos;\n";
+ .fs_exec = (" if (texelFetch(sampler, ivec2(mod(fill_pos,fill_size)), 0).x == 0)\n"
+ " gl_FragColor = bg;\n"
+ " else\n"
+ " gl_FragColor = fg;\n"),
+ .locations = glamor_program_location_fg | glamor_program_location_bg | glamor_program_location_fill
+ .use = use_opaque_stipple
+};
+#endif
+
+static const glamor_facet *glamor_facet_fill[4] = {
+ &glamor_fill_solid,
+ &glamor_fill_tile,
+ NULL,
+ NULL,
+};
+
+typedef struct {
+ glamor_program_location location;
+ const char *vs_vars;
+ const char *fs_vars;
+} glamor_location_var;
+
+static glamor_location_var location_vars[] = {
+ {
+ .location = glamor_program_location_fg,
+ .fs_vars = "uniform vec4 fg;\n"
+ },
+ {
+ .location = glamor_program_location_bg,
+ .fs_vars = "uniform vec4 bg;\n"
+ },
+ {
+ .location = glamor_program_location_fill,
+ .vs_vars = ("uniform vec2 fill_offset;\n"
+ "varying vec2 fill_pos;\n"),
+ .fs_vars = ("uniform sampler2D sampler;\n"
+ "uniform vec2 fill_size;\n"
+ "varying vec2 fill_pos;\n")
+ },
+ {
+ .location = glamor_program_location_font,
+ .fs_vars = "uniform usampler2D font;\n",
+ },
+};
+
+#define NUM_LOCATION_VARS (sizeof location_vars / sizeof location_vars[0])
+
+static char *
+add_var(char *cur, const char *add)
+{
+ char *new;
+
+ if (!add)
+ return cur;
+
+ new = realloc(cur, strlen(cur) + strlen(add) + 1);
+ if (!new) {
+ free(cur);
+ return NULL;
+ }
+ strcat(new, add);
+ return new;
+}
+
+static char *
+vs_location_vars(glamor_program_location locations)
+{
+ int l;
+ char *vars = strdup("");
+
+ for (l = 0; vars && l < NUM_LOCATION_VARS; l++)
+ if (locations & location_vars[l].location)
+ vars = add_var(vars, location_vars[l].vs_vars);
+ return vars;
+}
+
+static char *
+fs_location_vars(glamor_program_location locations)
+{
+ int l;
+ char *vars = strdup("");
+
+ for (l = 0; vars && l < NUM_LOCATION_VARS; l++)
+ if (locations & location_vars[l].location)
+ vars = add_var(vars, location_vars[l].fs_vars);
+ return vars;
+}
+
+static const char vs_template[] =
+ "%s" /* version */
+ "%s" /* prim vs_vars */
+ "%s" /* fill vs_vars */
+ "%s" /* location vs_vars */
+ GLAMOR_DECLARE_MATRIX
+ "void main() {\n"
+ "%s" /* prim vs_exec, outputs 'pos' and gl_Position */
+ "%s" /* fill vs_exec */
+ "}\n";
+
+static const char fs_template[] =
+ "%s" /* version */
+ GLAMOR_DEFAULT_PRECISION
+ "%s" /* prim fs_vars */
+ "%s" /* fill fs_vars */
+ "%s" /* location fs_vars */
+ "void main() {\n"
+ "%s" /* prim fs_exec */
+ "%s" /* fill fs_exec */
+ "}\n";
+
+static const char *
+str(const char *s)
+{
+ if (!s)
+ return "";
+ return s;
+}
+
+static const glamor_facet facet_null_fill = {
+ .name = ""
+};
+
+static GLint
+glamor_get_uniform(glamor_program *prog,
+ glamor_program_location location,
+ const char *name)
+{
+ GLint uniform;
+ if (location && (prog->locations & location) == 0)
+ return -2;
+ uniform = glGetUniformLocation(prog->prog, name);
+#if DBG
+ ErrorF("%s uniform %d\n", name, uniform);
+#endif
+ return uniform;
+}
+
+Bool
+glamor_build_program(ScreenPtr screen,
+ glamor_program *prog,
+ const glamor_facet *prim,
+ const glamor_facet *fill)
+{
+ glamor_screen_private *glamor_priv = glamor_get_screen_private(screen);
+
+ glamor_program_location locations = prim->locations;
+ glamor_program_flag flags = prim->flags;
+
+ int version = prim->version;
+ char *version_string = NULL;
+
+ char *fs_vars = NULL;
+ char *vs_vars = NULL;
+
+ char *vs_prog_string;
+ char *fs_prog_string;
+
+ GLint fs_prog, vs_prog;
+
+ if (!fill)
+ fill = &facet_null_fill;
+
+ locations |= fill->locations;
+ flags |= fill->flags;
+ version = MAX(version, fill->version);
+
+ if (version >= 130) {
+
+ /* Would be nice to have a cleaner test for GLSL 1.30 support,
+ * but for now this should suffice
+ */
+ if (glamor_priv->gl_flavor != GLAMOR_GL_DESKTOP ||
+ epoxy_gl_version() < 30) {
+ goto fail;
+ }
+ }
+
+ vs_vars = vs_location_vars(locations);
+ fs_vars = fs_location_vars(locations);
+
+ if (!vs_vars)
+ goto fail;
+ if (!fs_vars)
+ goto fail;
+
+ if (version) {
+ if (asprintf(&version_string, "#version %d\n", version) < 0)
+ version_string = NULL;
+ if (!version_string)
+ goto fail;
+ }
+
+ if (asprintf(&vs_prog_string,
+ vs_template,
+ str(version_string),
+ str(prim->vs_vars),
+ str(fill->vs_vars),
+ vs_vars,
+ str(prim->vs_exec),
+ str(fill->vs_exec)) < 0)
+ vs_prog_string = NULL;
+
+ if (asprintf(&fs_prog_string,
+ fs_template,
+ str(version_string),
+ str(prim->fs_vars),
+ str(fill->fs_vars),
+ fs_vars,
+ str(prim->fs_exec),
+ str(fill->fs_exec)) < 0)
+ fs_prog_string = NULL;
+
+ if (!vs_prog_string || !fs_prog_string)
+ goto fail;
+
+#define DBG 0
+#if DBG
+ ErrorF("\nPrograms for %s %s\nVertex shader:\n\n%s\n\nFragment Shader:\n\n%s",
+ prim->name, fill->name, vs_prog_string, fs_prog_string);
+#endif
+
+ prog->prog = glCreateProgram();
+ prog->flags = flags;
+ prog->locations = locations;
+ prog->prim_use = prim->use;
+ prog->fill_use = fill->use;
+
+ vs_prog = glamor_compile_glsl_prog(GL_VERTEX_SHADER, vs_prog_string);
+ fs_prog = glamor_compile_glsl_prog(GL_FRAGMENT_SHADER, fs_prog_string);
+ free(vs_prog_string);
+ free(fs_prog_string);
+ glAttachShader(prog->prog, vs_prog);
+ glDeleteShader(vs_prog);
+ glAttachShader(prog->prog, fs_prog);
+ glDeleteShader(fs_prog);
+ glBindAttribLocation(prog->prog, GLAMOR_VERTEX_POS, "primitive");
+
+ if (prim->source_name) {
+#if DBG
+ ErrorF("Bind GLAMOR_VERTEX_SOURCE to %s\n", prim->source_name);
+#endif
+ glBindAttribLocation(prog->prog, GLAMOR_VERTEX_SOURCE, prim->source_name);
+ }
+
+ glamor_link_glsl_prog(screen, prog->prog, "%s_%s", prim->name, fill->name);
+
+ prog->matrix_uniform = glamor_get_uniform(prog, glamor_program_location_none, "v_matrix");
+ prog->fg_uniform = glamor_get_uniform(prog, glamor_program_location_fg, "fg");
+ prog->bg_uniform = glamor_get_uniform(prog, glamor_program_location_bg, "bg");
+ prog->fill_offset_uniform = glamor_get_uniform(prog, glamor_program_location_fill, "fill_offset");
+ prog->fill_size_uniform = glamor_get_uniform(prog, glamor_program_location_fill, "fill_size");
+ prog->font_uniform = glamor_get_uniform(prog, glamor_program_location_font, "font");
+
+ if (glGetError() != GL_NO_ERROR)
+ goto fail;
+
+ free(version_string);
+ free(fs_vars);
+ free(vs_vars);
+ return TRUE;
+fail:
+ prog->failed = 1;
+ if (prog->prog) {
+ glDeleteProgram(prog->prog);
+ prog->prog = 0;
+ }
+ free(version_string);
+ free(fs_vars);
+ free(vs_vars);
+ return FALSE;
+}
+
+Bool
+glamor_use_program(PixmapPtr pixmap,
+ GCPtr gc,
+ glamor_program *prog,
+ void *arg)
+{
+ glUseProgram(prog->prog);
+
+ if (prog->prim_use && !prog->prim_use(pixmap, gc, prog, arg))
+ return FALSE;
+
+ if (prog->fill_use && !prog->fill_use(pixmap, gc, prog, arg))
+ return FALSE;
+
+ return TRUE;
+}
+
+glamor_program *
+glamor_use_program_fill(PixmapPtr pixmap,
+ GCPtr gc,
+ glamor_program_fill *program_fill,
+ const glamor_facet *prim)
+{
+ ScreenPtr screen = pixmap->drawable.pScreen;
+ glamor_program *prog = &program_fill->progs[gc->fillStyle];
+
+ int fill_style = gc->fillStyle;
+ const glamor_facet *fill;
+
+ if (prog->failed)
+ return FALSE;
+
+ if (!prog->prog) {
+ fill = glamor_facet_fill[fill_style];
+ if (!fill)
+ return NULL;
+
+ if (!glamor_build_program(screen, prog, prim, fill))
+ return NULL;
+ }
+
+ if (!glamor_use_program(pixmap, gc, prog, NULL))
+ return NULL;
+
+ return prog;
+}
diff --git a/xorg-server/glamor/glamor_program.h b/xorg-server/glamor/glamor_program.h
new file mode 100644
index 000000000..88efc3593
--- /dev/null
+++ b/xorg-server/glamor/glamor_program.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright © 2014 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _GLAMOR_PROGRAM_H_
+#define _GLAMOR_PROGRAM_H_
+
+typedef enum {
+ glamor_program_location_none = 0,
+ glamor_program_location_fg = 1,
+ glamor_program_location_bg = 2,
+ glamor_program_location_fill = 4,
+ glamor_program_location_font = 8,
+} glamor_program_location;
+
+typedef enum {
+ glamor_program_flag_none = 0,
+} glamor_program_flag;
+
+typedef struct _glamor_program glamor_program;
+
+typedef Bool (*glamor_use) (PixmapPtr pixmap, GCPtr gc, glamor_program *prog, void *arg);
+
+typedef struct {
+ const char *name;
+ const int version;
+ const char *vs_vars;
+ const char *vs_exec;
+ const char *fs_vars;
+ const char *fs_exec;
+ const glamor_program_location locations;
+ const glamor_program_flag flags;
+ const char *source_name;
+ glamor_use use;
+} glamor_facet;
+
+struct _glamor_program {
+ GLint prog;
+ GLint failed;
+ GLint matrix_uniform;
+ GLint fg_uniform;
+ GLint bg_uniform;
+ GLint fill_size_uniform;
+ GLint fill_offset_uniform;
+ GLint font_uniform;
+ glamor_program_location locations;
+ glamor_program_flag flags;
+ glamor_use prim_use;
+ glamor_use fill_use;
+};
+
+typedef struct {
+ glamor_program progs[4];
+} glamor_program_fill;
+
+extern const glamor_facet glamor_fill_solid;
+
+Bool
+glamor_build_program(ScreenPtr screen,
+ glamor_program *prog,
+ const glamor_facet *prim,
+ const glamor_facet *fill);
+
+Bool
+glamor_use_program(PixmapPtr pixmap,
+ GCPtr gc,
+ glamor_program *prog,
+ void *arg);
+
+glamor_program *
+glamor_use_program_fill(PixmapPtr pixmap,
+ GCPtr gc,
+ glamor_program_fill *program_fill,
+ const glamor_facet *prim);
+
+#endif /* _GLAMOR_PROGRAM_H_ */
diff --git a/xorg-server/glamor/glamor_render.c b/xorg-server/glamor/glamor_render.c
index c0ee22c2f..cdf8effdc 100644
--- a/xorg-server/glamor/glamor_render.c
+++ b/xorg-server/glamor/glamor_render.c
@@ -412,29 +412,10 @@ glamor_init_composite_shaders(ScreenPtr screen)
eb_size = GLAMOR_COMPOSITE_VBO_VERT_CNT * sizeof(short) * 2;
- if (glamor_priv->gl_flavor == GLAMOR_GL_DESKTOP) {
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, eb_size, NULL, GL_STATIC_DRAW);
- eb = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
- }
- else {
- eb = malloc(eb_size);
- }
-
- if (eb == NULL)
- FatalError
- ("fatal error, fail to get element buffer. GL context may be not created correctly.\n");
+ eb = XNFalloc(eb_size);
glamor_init_eb(eb, GLAMOR_COMPOSITE_VBO_VERT_CNT);
-
- if (glamor_priv->gl_flavor == GLAMOR_GL_DESKTOP) {
- glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
- }
- else {
- glBufferData(GL_ELEMENT_ARRAY_BUFFER, eb_size, eb, GL_STATIC_DRAW);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
- free(eb);
- }
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, eb_size, eb, GL_STATIC_DRAW);
+ free(eb);
glamor_put_context(glamor_priv);
}
@@ -448,6 +429,7 @@ glamor_fini_composite_shaders(ScreenPtr screen)
glamor_priv = glamor_get_screen_private(screen);
glamor_get_context(glamor_priv);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &glamor_priv->ebo);
for (i = 0; i < SHADER_SOURCE_COUNT; i++)
@@ -706,8 +688,6 @@ glamor_setup_composite_vbo(ScreenPtr screen, int n_verts)
glamor_get_context(glamor_priv);
vb = glamor_get_vbo_space(screen, vert_size, &vbo_offset);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, glamor_priv->ebo);
-
glVertexAttribPointer(GLAMOR_VERTEX_POS, 2, GL_FLOAT, GL_FALSE,
glamor_priv->vb_stride, vbo_offset);
glEnableVertexAttribArray(GLAMOR_VERTEX_POS);
@@ -1329,7 +1309,6 @@ glamor_composite_with_shader(CARD8 op,
}
}
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
glDisableVertexAttribArray(GLAMOR_VERTEX_MASK);
diff --git a/xorg-server/glamor/glamor_segment.c b/xorg-server/glamor/glamor_segment.c
new file mode 100644
index 000000000..84b27acce
--- /dev/null
+++ b/xorg-server/glamor/glamor_segment.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2014 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#include "glamor_priv.h"
+
+Bool
+glamor_poly_segment_nf(DrawablePtr drawable, GCPtr gc, int nseg,
+ xSegment *seg)
+{
+ return FALSE;
+}
+
+void
+glamor_poly_segment(DrawablePtr drawable, GCPtr gc, int nseg,
+ xSegment *seg)
+{
+ if (glamor_poly_segment_nf(drawable, gc, nseg, seg))
+ return;
+ miPolySegment(drawable, gc, nseg, seg);
+}
diff --git a/xorg-server/glamor/glamor_transform.c b/xorg-server/glamor/glamor_transform.c
new file mode 100644
index 000000000..d6ba56421
--- /dev/null
+++ b/xorg-server/glamor/glamor_transform.c
@@ -0,0 +1,215 @@
+/*
+ * Copyright © 2014 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#include "glamor_priv.h"
+#include "glamor_transform.h"
+
+
+/*
+ * Set up rendering to target the specified drawable, computing an
+ * appropriate transform for the vertex shader to convert
+ * drawable-relative coordinates into pixmap-relative coordinates. If
+ * requested, the offset from pixmap origin coordinates back to window
+ * system coordinates will be returned in *p_off_x, *p_off_y so that
+ * clipping computations can be adjusted as appropriate
+ */
+
+void
+glamor_set_destination_drawable(DrawablePtr drawable,
+ int box_x,
+ int box_y,
+ Bool do_drawable_translate,
+ Bool center_offset,
+ GLint matrix_uniform_location,
+ int *p_off_x,
+ int *p_off_y)
+{
+ PixmapPtr pixmap = glamor_get_drawable_pixmap(drawable);
+ glamor_pixmap_private *pixmap_priv = glamor_get_pixmap_private(pixmap);
+ int off_x, off_y;
+ BoxPtr box = glamor_pixmap_box_at(pixmap_priv, box_x, box_y);
+ int w = box->x2 - box->x1;
+ int h = box->y2 - box->y1;
+ float scale_x = 2.0f / (float) w;
+ float scale_y = 2.0f / (float) h;
+ float center_adjust = 0.0f;
+
+ glamor_get_drawable_deltas(drawable, pixmap, &off_x, &off_y);
+
+ off_x -= box->x1;
+ off_y -= box->y1;
+
+ if (p_off_x) {
+ *p_off_x = off_x;
+ *p_off_y = off_y;
+ }
+
+ /* A tricky computation to find the right value for the two linear functions
+ * that transform rendering coordinates to pixmap coordinates
+ *
+ * pixmap_x = render_x + drawable->x + off_x
+ * pixmap_y = render_y + drawable->y + off_y
+ *
+ * gl_x = pixmap_x * 2 / width - 1
+ * gl_y = pixmap_y * 2 / height - 1
+ *
+ * gl_x = (render_x + drawable->x + off_x) * 2 / width - 1
+ *
+ * gl_x = (render_x) * 2 / width + (drawable->x + off_x) * 2 / width - 1
+ *
+ * I'll think about yInverted later, when I have some way to test
+ */
+
+ if (do_drawable_translate) {
+ off_x += drawable->x;
+ off_y += drawable->y;
+ }
+
+ /*
+ * To get GL_POINTS drawn in the right spot, we need to adjust the
+ * coordinates by 1/2 a pixel.
+ */
+ if (center_offset)
+ center_adjust = 0.5f;
+
+ glUniform4f(matrix_uniform_location,
+ scale_x, (off_x + center_adjust) * scale_x - 1.0f,
+ scale_y, (off_y + center_adjust) * scale_y - 1.0f);
+
+ glamor_set_destination_pixmap_fbo(glamor_pixmap_fbo_at(pixmap_priv, box_x, box_y),
+ 0, 0, w, h);
+}
+
+/*
+ * Set up for solid rendering to the specified pixmap using alu, fg and planemask
+ * from the specified GC. Load the target color into the specified uniform
+ */
+
+void
+glamor_set_color(PixmapPtr pixmap,
+ CARD32 pixel,
+ GLint uniform)
+{
+ float color[4];
+
+ glamor_get_rgba_from_pixel(pixel,
+ &color[0], &color[1], &color[2], &color[3],
+ format_for_pixmap(pixmap));
+
+ glUniform4fv(uniform, 1, color);
+}
+
+Bool
+glamor_set_solid(PixmapPtr pixmap,
+ GCPtr gc,
+ Bool use_alu,
+ GLint uniform)
+{
+ CARD32 pixel;
+ int alu = use_alu ? gc->alu : GXcopy;
+
+ if (!glamor_set_planemask(pixmap, gc->planemask))
+ return FALSE;
+
+ pixel = gc->fgPixel;
+
+ if (!glamor_set_alu(pixmap->drawable.pScreen, alu)) {
+ switch (gc->alu) {
+ case GXclear:
+ pixel = 0;
+ break;
+ case GXcopyInverted:
+ pixel = ~pixel;
+ break;
+ case GXset:
+ pixel = ~0 & gc->planemask;
+ break;
+ default:
+ return FALSE;
+ }
+ }
+ glamor_set_color(pixmap, gc->fgPixel, uniform);
+
+ return TRUE;
+}
+
+Bool
+glamor_set_texture(PixmapPtr pixmap,
+ PixmapPtr texture,
+ int off_x,
+ int off_y,
+ GLint offset_uniform,
+ GLint size_uniform)
+{
+ glamor_pixmap_private *texture_priv;
+
+ texture_priv = glamor_get_pixmap_private(texture);
+
+ if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(texture_priv))
+ return FALSE;
+
+ if (texture_priv->type == GLAMOR_TEXTURE_LARGE)
+ return FALSE;
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, texture_priv->base.fbo->tex);
+
+ glUniform2f(offset_uniform, off_x, off_y);
+ glUniform2f(size_uniform, texture->drawable.width, texture->drawable.height);
+ return TRUE;
+}
+
+Bool
+glamor_set_tiled(PixmapPtr pixmap,
+ GCPtr gc,
+ GLint offset_uniform,
+ GLint size_uniform)
+{
+ if (!glamor_set_alu(pixmap->drawable.pScreen, gc->alu))
+ return FALSE;
+
+ if (!glamor_set_planemask(pixmap, gc->planemask))
+ return FALSE;
+
+ return glamor_set_texture(pixmap,
+ gc->tile.pixmap,
+ -gc->patOrg.x,
+ -gc->patOrg.y,
+ offset_uniform,
+ size_uniform);
+}
+
+Bool
+glamor_set_stippled(PixmapPtr pixmap,
+ GCPtr gc,
+ GLint fg_uniform,
+ GLint offset_uniform,
+ GLint size_uniform)
+{
+ if (!glamor_set_solid(pixmap, gc, TRUE, fg_uniform))
+ return FALSE;
+
+ if (!glamor_set_texture(pixmap, gc->stipple, gc->patOrg.x, gc->patOrg.y, offset_uniform, size_uniform))
+ return FALSE;
+
+ return TRUE;
+}
diff --git a/xorg-server/glamor/glamor_transform.h b/xorg-server/glamor/glamor_transform.h
new file mode 100644
index 000000000..36b789af8
--- /dev/null
+++ b/xorg-server/glamor/glamor_transform.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright © 2014 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _GLAMOR_TRANSFORM_H_
+#define _GLAMOR_TRANSFORM_H_
+
+void
+glamor_set_destination_drawable(DrawablePtr drawable,
+ int box_x,
+ int box_y,
+ Bool do_drawable_translate,
+ Bool center_offset,
+ GLint matrix_uniform_location,
+ int *p_off_x,
+ int *p_off_y);
+
+void
+glamor_set_color(PixmapPtr pixmap,
+ CARD32 pixel,
+ GLint uniform);
+
+Bool
+glamor_set_texture(PixmapPtr pixmap,
+ PixmapPtr texture,
+ int off_x,
+ int off_y,
+ GLint offset_uniform,
+ GLint size_uniform);
+
+Bool
+glamor_set_solid(PixmapPtr pixmap,
+ GCPtr gc,
+ Bool use_alu,
+ GLint uniform);
+
+Bool
+glamor_set_tiled(PixmapPtr pixmap,
+ GCPtr gc,
+ GLint offset_uniform,
+ GLint size_uniform);
+
+Bool
+glamor_set_stippled(PixmapPtr pixmap,
+ GCPtr gc,
+ GLint fg_uniform,
+ GLint offset_uniform,
+ GLint size_uniform);
+
+/*
+ * Vertex shader bits that transform X coordinates to pixmap
+ * coordinates using the matrix computed above
+ */
+
+#define GLAMOR_DECLARE_MATRIX "uniform vec4 v_matrix;\n"
+#define GLAMOR_X_POS(x) #x " *v_matrix.x + v_matrix.y"
+#define GLAMOR_Y_POS(y) #y " *v_matrix.z + v_matrix.w"
+#if 0
+#define GLAMOR_POS(dst,src) \
+ " " #dst ".x = " #src ".x * v_matrix.x + v_matrix.y;\n" \
+ " " #dst ".y = " #src ".y * v_matrix.z + v_matrix.w;\n" \
+ " " #dst ".z = 0.0;\n" \
+ " " #dst ".w = 1.0;\n"
+#endif
+#define GLAMOR_POS(dst,src) \
+ " " #dst ".xy = " #src ".xy * v_matrix.xz + v_matrix.yw;\n" \
+ " " #dst ".zw = vec2(0.0,1.0);\n"
+
+#endif /* _GLAMOR_TRANSFORM_H_ */
diff --git a/xorg-server/glamor/glamor_trapezoid.c b/xorg-server/glamor/glamor_trapezoid.c
index 969ab68bc..c76b8bb2a 100644
--- a/xorg-server/glamor/glamor_trapezoid.c
+++ b/xorg-server/glamor/glamor_trapezoid.c
@@ -637,8 +637,6 @@ glamor_setup_composite_vbo_for_trapezoid(ScreenPtr screen, int n_verts)
vb = glamor_get_vbo_space(screen, vert_size, &vbo_offset);
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, glamor_priv->ebo);
-
/* Set the vertex pointer. */
glVertexAttribPointer(GLAMOR_VERTEX_POS, 2, GL_FLOAT,
GL_FALSE, glamor_priv->vb_stride,
@@ -977,7 +975,6 @@ _glamor_trapezoids_with_shader(CARD8 op,
ret = TRUE;
TRAPEZOID_RESET_GL:
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
glDisableVertexAttribArray(GLAMOR_VERTEX_SOURCE);
glDisableVertexAttribArray(GLAMOR_VERTEX_MASK);
@@ -1415,8 +1412,6 @@ _glamor_generate_trapezoid_with_shader(ScreenPtr screen, PicturePtr picture,
pixmap_priv_get_dest_scale(pixmap_priv, (&xscale), (&yscale));
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
/* Now draw the Trapezoid mask. */
glUseProgram(trapezoid_prog);
@@ -1562,7 +1557,6 @@ _glamor_generate_trapezoid_with_shader(ScreenPtr screen, PicturePtr picture,
}
}
- glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBlendFunc(GL_ONE, GL_ZERO);
glDisable(GL_BLEND);
glDisableVertexAttribArray(GLAMOR_VERTEX_POS);
diff --git a/xorg-server/glamor/glamor_vbo.c b/xorg-server/glamor/glamor_vbo.c
index 5e98bfe47..2731692d6 100644
--- a/xorg-server/glamor/glamor_vbo.c
+++ b/xorg-server/glamor/glamor_vbo.c
@@ -96,7 +96,7 @@ glamor_get_vbo_space(ScreenPtr screen, unsigned size, char **vbo_offset)
*vbo_offset = (void *)(uintptr_t)glamor_priv->vbo_offset;
data = glamor_priv->vb + glamor_priv->vbo_offset;
glamor_priv->vbo_offset += size;
- } else if (glamor_priv->gl_flavor == GLAMOR_GL_DESKTOP) {
+ } else if (glamor_priv->has_map_buffer_range) {
if (glamor_priv->vbo_size < glamor_priv->vbo_offset + size) {
glamor_priv->vbo_size = MAX(GLAMOR_VBO_SIZE, size);
glamor_priv->vbo_offset = 0;
@@ -147,7 +147,7 @@ glamor_put_vbo_space(ScreenPtr screen)
* persistent mapping, so we can leave it around until we
* reach the end of the buffer.
*/
- } else if (glamor_priv->gl_flavor == GLAMOR_GL_DESKTOP) {
+ } else if (glamor_priv->has_map_buffer_range) {
glUnmapBuffer(GL_ARRAY_BUFFER);
} else {
glBufferData(GL_ARRAY_BUFFER, glamor_priv->vbo_offset,
@@ -179,7 +179,7 @@ glamor_fini_vbo(ScreenPtr screen)
glamor_get_context(glamor_priv);
glDeleteBuffers(1, &glamor_priv->vbo);
- if (glamor_priv->gl_flavor != GLAMOR_GL_DESKTOP)
+ if (!glamor_priv->has_map_buffer_range)
free(glamor_priv->vb);
glamor_put_context(glamor_priv);
diff --git a/xorg-server/hw/dmx/dmxinit.c b/xorg-server/hw/dmx/dmxinit.c
index 7adcba0bb..fd2ade0ef 100644
--- a/xorg-server/hw/dmx/dmxinit.c
+++ b/xorg-server/hw/dmx/dmxinit.c
@@ -597,10 +597,8 @@ static void dmxAddExtensions(Bool glxSupported)
{ GlxExtensionInit, "GLX", &glxSupported },
#endif
};
- int i;
- for (i = 0; i < ARRAY_SIZE(dmxExtensions); i++)
- LoadExtension(&dmxExtensions[i], TRUE);
+ LoadExtensionList(dmxExtensions, ARRAY_SIZE(dmxExtensions), TRUE);
}
/** This routine is called in Xserver/dix/main.c from \a main(). */
diff --git a/xorg-server/hw/kdrive/ephyr/Makefile.am b/xorg-server/hw/kdrive/ephyr/Makefile.am
index 040993ce0..00a53d0df 100644
--- a/xorg-server/hw/kdrive/ephyr/Makefile.am
+++ b/xorg-server/hw/kdrive/ephyr/Makefile.am
@@ -38,7 +38,7 @@ if GLAMOR
GLAMOR_SRCS = \
ephyr_glamor_glx.c \
ephyr_glamor_glx.h \
- ()
+ $()
endif
if DRI
diff --git a/xorg-server/hw/kdrive/ephyr/ephyrinit.c b/xorg-server/hw/kdrive/ephyr/ephyrinit.c
index 807e717b1..fac84cd13 100644
--- a/xorg-server/hw/kdrive/ephyr/ephyrinit.c
+++ b/xorg-server/hw/kdrive/ephyr/ephyrinit.c
@@ -65,10 +65,7 @@ static const ExtensionModule ephyrExtensions[] = {
static
void ephyrExtensionInit(void)
{
- int i;
-
- for (i = 0; i < ARRAY_SIZE(ephyrExtensions); i++)
- LoadExtension(&ephyrExtensions[i], TRUE);
+ LoadExtensionList(ephyrExtensions, ARRAY_SIZE(ephyrExtensions), TRUE);
}
diff --git a/xorg-server/hw/kdrive/ephyr/hostx.c b/xorg-server/hw/kdrive/ephyr/hostx.c
index 3260d9527..4f48770a6 100644
--- a/xorg-server/hw/kdrive/ephyr/hostx.c
+++ b/xorg-server/hw/kdrive/ephyr/hostx.c
@@ -710,6 +710,12 @@ hostx_screen_init(KdScreenInfo *screen,
malloc(scrpriv->ximg->stride * buffer_height);
}
+ {
+ uint32_t mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
+ uint32_t values[2] = {width, height};
+ xcb_configure_window(HostX.conn, scrpriv->win, mask, values);
+ }
+
if (scrpriv->win_pre_existing == None && !EphyrWantResize) {
/* Ask the WM to keep our size static */
xcb_size_hints_t size_hints = {0};
@@ -1260,7 +1266,9 @@ ephyr_glamor_create_screen_resources(ScreenPtr pScreen)
screen_pixmap = pScreen->CreatePixmap(pScreen,
pScreen->width,
pScreen->height,
- pScreen->rootDepth, 0);
+ pScreen->rootDepth,
+ GLAMOR_CREATE_NO_LARGE);
+
pScreen->SetScreenPixmap(screen_pixmap);
/* Tell the GLX code what to GL texture to read from. */
diff --git a/xorg-server/hw/kdrive/src/kxv.c b/xorg-server/hw/kdrive/src/kxv.c
index 445eb605b..9cc0edd8a 100644
--- a/xorg-server/hw/kdrive/src/kxv.c
+++ b/xorg-server/hw/kdrive/src/kxv.c
@@ -385,28 +385,7 @@ KdXVInitAdaptors(ScreenPtr pScreen, KdVideoAdaptorPtr * infoPtr, int number)
for (i = 0, pi = pImage, imagePtr = adaptorPtr->pImages;
i < adaptorPtr->nImages; i++, pi++, imagePtr++) {
- pi->id = imagePtr->id;
- pi->type = imagePtr->type;
- pi->byte_order = imagePtr->byte_order;
- memcpy(pi->guid, imagePtr->guid, 16);
- pi->bits_per_pixel = imagePtr->bits_per_pixel;
- pi->format = imagePtr->format;
- pi->num_planes = imagePtr->num_planes;
- pi->depth = imagePtr->depth;
- pi->red_mask = imagePtr->red_mask;
- pi->green_mask = imagePtr->green_mask;
- pi->blue_mask = imagePtr->blue_mask;
- pi->y_sample_bits = imagePtr->y_sample_bits;
- pi->u_sample_bits = imagePtr->u_sample_bits;
- pi->v_sample_bits = imagePtr->v_sample_bits;
- pi->horz_y_period = imagePtr->horz_y_period;
- pi->horz_u_period = imagePtr->horz_u_period;
- pi->horz_v_period = imagePtr->horz_v_period;
- pi->vert_y_period = imagePtr->vert_y_period;
- pi->vert_u_period = imagePtr->vert_u_period;
- pi->vert_v_period = imagePtr->vert_v_period;
- memcpy(pi->component_order, imagePtr->component_order, 32);
- pi->scanline_order = imagePtr->scanline_order;
+ memcpy(pi, imagePtr, sizeof(*pi));
}
pa->nImages = adaptorPtr->nImages;
pa->pImages = pImage;
@@ -417,9 +396,7 @@ KdXVInitAdaptors(ScreenPtr pScreen, KdVideoAdaptorPtr * infoPtr, int number)
calloc(adaptorPtr->nAttributes, sizeof(XvAttributeRec)))) {
for (pat = pAttribute, attributePtr = adaptorPtr->pAttributes, i =
0; i < adaptorPtr->nAttributes; pat++, i++, attributePtr++) {
- pat->flags = attributePtr->flags;
- pat->min_value = attributePtr->min_value;
- pat->max_value = attributePtr->max_value;
+ memcpy(pat, attributePtr, sizeof(*pat));
pat->name = strdup(attributePtr->name);
}
pa->nAttributes = adaptorPtr->nAttributes;
diff --git a/xorg-server/hw/kdrive/src/kxv.h b/xorg-server/hw/kdrive/src/kxv.h
index 4f644c246..85a030ee9 100644
--- a/xorg-server/hw/kdrive/src/kxv.h
+++ b/xorg-server/hw/kdrive/src/kxv.h
@@ -56,34 +56,7 @@ of the copyright holder.
#define VIDEO_OVERLAID_STILLS 0x00000008
#define VIDEO_CLIP_TO_VIEWPORT 0x00000010
-typedef struct {
- int id;
- int type;
- int byte_order;
- unsigned char guid[16];
- int bits_per_pixel;
- int format;
- int num_planes;
-
- /* for RGB formats only */
- int depth;
- unsigned int red_mask;
- unsigned int green_mask;
- unsigned int blue_mask;
-
- /* for YUV formats only */
- unsigned int y_sample_bits;
- unsigned int u_sample_bits;
- unsigned int v_sample_bits;
- unsigned int horz_y_period;
- unsigned int horz_u_period;
- unsigned int horz_v_period;
- unsigned int vert_y_period;
- unsigned int vert_u_period;
- unsigned int vert_v_period;
- char component_order[32];
- int scanline_order;
-} KdImageRec, *KdImagePtr;
+typedef XvImageRec KdImageRec, *KdImagePtr;
typedef struct {
KdScreenInfo *screen;
@@ -158,12 +131,7 @@ typedef struct {
short class;
} KdVideoFormatRec, *KdVideoFormatPtr;
-typedef struct {
- int flags;
- int min_value;
- int max_value;
- char *name;
-} KdAttributeRec, *KdAttributePtr;
+typedef XvAttributeRec KdAttributeRec, *KdAttributePtr;
typedef struct {
unsigned int type;
diff --git a/xorg-server/hw/vfb/InitOutput.c b/xorg-server/hw/vfb/InitOutput.c
index 2175ac685..9c4926462 100644
--- a/xorg-server/hw/vfb/InitOutput.c
+++ b/xorg-server/hw/vfb/InitOutput.c
@@ -892,10 +892,7 @@ static const ExtensionModule vfbExtensions[] = {
static
void vfbExtensionInit(void)
{
- int i;
-
- for (i = 0; i < ARRAY_SIZE(vfbExtensions); i++)
- LoadExtension(&vfbExtensions[i], TRUE);
+ LoadExtensionList(vfbExtensions, ARRAY_SIZE(vfbExtensions), TRUE);
}
void
diff --git a/xorg-server/hw/xfree86/Makefile.am b/xorg-server/hw/xfree86/Makefile.am
index a315bbc17..18fa99b08 100644
--- a/xorg-server/hw/xfree86/Makefile.am
+++ b/xorg-server/hw/xfree86/Makefile.am
@@ -43,7 +43,7 @@ SUBDIRS = common ddc x86emu $(INT10_SUBDIR) os-support parser \
DIST_SUBDIRS = common ddc i2c x86emu int10 fbdevhw os-support \
parser ramdac shadowfb vbe vgahw \
loader dixmods dri dri2 exa modes \
- utils doc man
+ utils doc man glamor_egl
bin_PROGRAMS = Xorg
nodist_Xorg_SOURCES = sdksyms.c
diff --git a/xorg-server/hw/xfree86/common/xf86Extensions.c b/xorg-server/hw/xfree86/common/xf86Extensions.c
index c80de34e6..25b2bc3d0 100644
--- a/xorg-server/hw/xfree86/common/xf86Extensions.c
+++ b/xorg-server/hw/xfree86/common/xf86Extensions.c
@@ -132,10 +132,7 @@ load_extension_config(void)
void
xf86ExtensionInit(void)
{
- int i;
-
load_extension_config();
- for (i = 0; i < ARRAY_SIZE(extensionModules); i++)
- LoadExtension(&extensionModules[i], TRUE);
+ LoadExtensionList(extensionModules, ARRAY_SIZE(extensionModules), TRUE);
}
diff --git a/xorg-server/hw/xfree86/dixmods/glxmodule.c b/xorg-server/hw/xfree86/dixmods/glxmodule.c
index bf7d182a2..d53c6652d 100644
--- a/xorg-server/hw/xfree86/dixmods/glxmodule.c
+++ b/xorg-server/hw/xfree86/dixmods/glxmodule.c
@@ -47,10 +47,8 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
static MODULESETUPPROTO(glxSetup);
-static const ExtensionModule GLXExt = {
- GlxExtensionInit,
- "GLX",
- &noGlxExtension
+static const ExtensionModule GLXExt[] = {
+ { GlxExtensionInit, "GLX", &noGlxExtension },
};
static XF86ModuleVersionInfo VersRec = {
@@ -90,7 +88,7 @@ glxSetup(void *module, void *opts, int *errmaj, int *errmin)
GlxPushProvider(provider);
}
- LoadExtension(&GLXExt, FALSE);
+ LoadExtensionList(GLXExt, ARRAY_SIZE(GLXExt), FALSE);
return module;
}
diff --git a/xorg-server/hw/xfree86/doc/ddxDesign.xml b/xorg-server/hw/xfree86/doc/ddxDesign.xml
index 7c2c20ff3..d1fd9af7b 100644
--- a/xorg-server/hw/xfree86/doc/ddxDesign.xml
+++ b/xorg-server/hw/xfree86/doc/ddxDesign.xml
@@ -5920,10 +5920,10 @@ These may be moved out of the loader at some point.
<blockquote><para>
<programlisting>
- void LoadExtension(ExtensionModule *ext);
+ void LoadExtensionList(const ExtensionModule ext[]);
</programlisting>
<blockquote><para>
- This registers the entry points for the extension identified by
+ This registers the entry points for the extension array identified by
<parameter>ext</parameter>. The <structname>ExtensionModule</structname> struct is
defined as:
diff --git a/xorg-server/hw/xquartz/quartz.c b/xorg-server/hw/xquartz/quartz.c
index bc6c8d048..d7229cecb 100644
--- a/xorg-server/hw/xquartz/quartz.c
+++ b/xorg-server/hw/xquartz/quartz.c
@@ -164,10 +164,7 @@ static const ExtensionModule quartzExtensions[] = {
*/
static void QuartzExtensionInit(void)
{
- int i;
-
- for (i = 0; i < ARRAY_SIZE(quartzExtensions); i++)
- LoadExtension(&quartzExtensions[i], TRUE);
+ LoadExtensionList(quartzExtensions, ARRAY_SIZE(quartzExtensions), TRUE);
}
/*
diff --git a/xorg-server/hw/xwin/InitOutput.c b/xorg-server/hw/xwin/InitOutput.c
index b3ff7c041..6b5c38d92 100644
--- a/xorg-server/hw/xwin/InitOutput.c
+++ b/xorg-server/hw/xwin/InitOutput.c
@@ -163,8 +163,6 @@ static const ExtensionModule xwinExtensions[] = {
static
void XwinExtensionInit(void)
{
- int i;
-
#ifdef XWIN_GLX_WINDOWS
if (g_fNativeGl) {
/* install the native GL provider */
@@ -172,8 +170,7 @@ void XwinExtensionInit(void)
}
#endif
- for (i = 0; i < ARRAY_SIZE(xwinExtensions); i++)
- LoadExtension(&xwinExtensions[i], TRUE);
+ LoadExtensionList(xwinExtensions, ARRAY_SIZE(xwinExtensions), TRUE);
}
#if defined(DDXBEFORERESET)
diff --git a/xorg-server/include/extension.h b/xorg-server/include/extension.h
index acc6addb7..7c09af150 100644
--- a/xorg-server/include/extension.h
+++ b/xorg-server/include/extension.h
@@ -97,6 +97,7 @@ extern _X_EXPORT void InitExtensions(int argc, char **argv);
extern _X_EXPORT void CloseDownExtensions(void);
-extern _X_EXPORT void LoadExtension(const ExtensionModule *ext, Bool external);
+extern _X_EXPORT void LoadExtensionList(const ExtensionModule ext[],
+ int listSize, Bool external);
#endif /* EXTENSION_H */
diff --git a/xorg-server/include/opaque.h b/xorg-server/include/opaque.h
index 73d40c345..7ec1d850f 100644
--- a/xorg-server/include/opaque.h
+++ b/xorg-server/include/opaque.h
@@ -74,5 +74,6 @@ extern _X_EXPORT Bool whiteRoot;
extern _X_EXPORT Bool bgNoneRoot;
extern _X_EXPORT Bool CoreDump;
+extern _X_EXPORT Bool NoListenAll;
#endif /* OPAQUE_H */
diff --git a/xorg-server/include/os.h b/xorg-server/include/os.h
index e5f86d67d..d26e399b6 100644
--- a/xorg-server/include/os.h
+++ b/xorg-server/include/os.h
@@ -166,9 +166,9 @@ extern _X_EXPORT void MakeClientGrabImpervious(ClientPtr /*client */ );
extern _X_EXPORT void MakeClientGrabPervious(ClientPtr /*client */ );
-#ifdef XQUARTZ
-extern void ListenOnOpenFD(int /* fd */ , int /* noxauth */ );
-#endif
+extern _X_EXPORT void ListenOnOpenFD(int /* fd */ , int /* noxauth */ );
+
+extern _X_EXPORT Bool AddClientOnOpenFD(int /* fd */ );
extern _X_EXPORT CARD32 GetTimeInMillis(void);
extern _X_EXPORT CARD64 GetTimeInMicros(void);
diff --git a/xorg-server/include/xkbsrv.h b/xorg-server/include/xkbsrv.h
index a80e11970..229de2194 100644
--- a/xorg-server/include/xkbsrv.h
+++ b/xorg-server/include/xkbsrv.h
@@ -824,6 +824,9 @@ extern _X_EXPORT void XkbSendNewKeyboardNotify(DeviceIntPtr /* kbd */ ,
extern Bool XkbCopyKeymap(XkbDescPtr /* dst */ ,
XkbDescPtr /* src */ );
+extern _X_EXPORT Bool XkbCopyDeviceKeymap(DeviceIntPtr /* dst */,
+ DeviceIntPtr /* src */);
+
extern _X_EXPORT Bool XkbDeviceApplyKeymap(DeviceIntPtr /* dst */ ,
XkbDescPtr /* src */ );
diff --git a/xorg-server/mi/mibitblt.c b/xorg-server/mi/mibitblt.c
index b0d14ae55..3ed4ed1cc 100644
--- a/xorg-server/mi/mibitblt.c
+++ b/xorg-server/mi/mibitblt.c
@@ -730,7 +730,7 @@ miPutImage(DrawablePtr pDraw, GCPtr pGC, int depth,
ChangeGC(NullClient, pGC, GCForeground | GCBackground, gcv);
bytesPer = (long) h *BitmapBytePad(w + leftPad);
- for (i = 1 << (depth - 1); i != 0; i >>= 1, pImage += bytesPer) {
+ for (i = (unsigned long) 1 << (depth - 1); i != 0; i >>= 1, pImage += bytesPer) {
if (i & oldPlanemask) {
gcv[0].val = (XID) i;
ChangeGC(NullClient, pGC, GCPlaneMask, gcv);
diff --git a/xorg-server/mi/miinitext.c b/xorg-server/mi/miinitext.c
index 67511b8d0..5b45ab4c2 100644
--- a/xorg-server/mi/miinitext.c
+++ b/xorg-server/mi/miinitext.c
@@ -234,7 +234,7 @@ EnableDisableExtensionError(const char *name, Bool enable)
}
/* List of built-in (statically linked) extensions */
-static ExtensionModule staticExtensions[] = {
+static const ExtensionModule staticExtensions[] = {
{GEExtensionInit, "Generic Event Extension", &noGEExtension},
{ShapeExtensionInit, "SHAPE", NULL},
#ifdef MITSHM
@@ -312,15 +312,13 @@ static void
AddStaticExtensions(void)
{
static Bool listInitialised = FALSE;
- int i;
if (listInitialised)
return;
listInitialised = TRUE;
/* Add built-in extensions to the list. */
- for (i = 0; i < ARRAY_SIZE(staticExtensions); i++)
- LoadExtension(&staticExtensions[i], TRUE);
+ LoadExtensionList(staticExtensions, ARRAY_SIZE(staticExtensions), TRUE);
}
void
@@ -331,7 +329,7 @@ InitExtensions(int argc, char *argv[])
AddStaticExtensions();
- for (i = 0; ExtensionModuleList[i].name != NULL; i++) {
+ for (i = 0; i < numExtensionModules; i++) {
ext = &ExtensionModuleList[i];
if (ext->initFunc != NULL &&
(ext->disablePtr == NULL || !*ext->disablePtr)) {
@@ -341,50 +339,52 @@ InitExtensions(int argc, char *argv[])
}
static ExtensionModule *
-NewExtensionModule(void)
+NewExtensionModuleList(int size)
{
ExtensionModule *save = ExtensionModuleList;
int n;
- /* Make sure built-in extensions get added to the list before those
- * in modules. */
- AddStaticExtensions();
-
/* Sanity check */
if (!ExtensionModuleList)
numExtensionModules = 0;
- n = numExtensionModules + 1;
+ n = numExtensionModules + size;
ExtensionModuleList = realloc(ExtensionModuleList,
- (n + 1) * sizeof(ExtensionModule));
+ n * sizeof(ExtensionModule));
if (ExtensionModuleList == NULL) {
ExtensionModuleList = save;
return NULL;
}
else {
- numExtensionModules++;
- ExtensionModuleList[numExtensionModules].name = NULL;
- return ExtensionModuleList + (numExtensionModules - 1);
+ numExtensionModules += size;
+ return ExtensionModuleList + (numExtensionModules - size);
}
}
void
-LoadExtension(const ExtensionModule * e, Bool builtin)
+LoadExtensionList(const ExtensionModule ext[], int size, Bool builtin)
{
ExtensionModule *newext;
+ const char *msg;
+ int i;
- if (e == NULL || e->name == NULL)
- return;
+ /* Make sure built-in extensions get added to the list before those
+ * in modules. */
+ AddStaticExtensions();
- if (!(newext = NewExtensionModule()))
+ if (!(newext = NewExtensionModuleList(size)))
return;
if (builtin)
- ErrorF("Initializing built-in extension %s\n", e->name);
+ msg = "Initializing built-in";
else
- ErrorF("Loading extension %s\n", e->name);
+ msg = "Loading";
+
+ for (i = 0; i < size; i++, newext++) {
+ ErrorF("%s extension %s\n", msg, ext[i].name);
- newext->name = e->name;
- newext->initFunc = e->initFunc;
- newext->disablePtr = e->disablePtr;
+ newext->name = ext[i].name;
+ newext->initFunc = ext[i].initFunc;
+ newext->disablePtr = ext[i].disablePtr;
+ }
}
diff --git a/xorg-server/os/connection.c b/xorg-server/os/connection.c
index ddf4f0a3a..b3640b8e4 100644
--- a/xorg-server/os/connection.c
+++ b/xorg-server/os/connection.c
@@ -138,6 +138,7 @@ fd_set OutputPending; /* clients with reply/event data ready to go */
int MaxClients = 0;
Bool NewOutputPending; /* not yet attempted to write some new output */
Bool AnyClientsWriteBlocked; /* true if some client blocked on write */
+Bool NoListenAll; /* Don't establish any listening sockets */
static Bool RunFromSmartParent; /* send SIGUSR1 to parent process */
Bool RunFromSigStopParent; /* send SIGSTOP to our own process; Upstart (or
@@ -406,7 +407,10 @@ CreateWellKnownSockets(void)
/* display is initialized to "0" by main(). It is then set to the display
* number if specified on the command line, or to NULL when the -displayfd
* option is used. */
- if (display) {
+ if (NoListenAll) {
+ ListenTransCount = 0;
+ }
+ else if (display) {
if (TryCreateSocket(atoi(display), &partial) &&
ListenTransCount >= 1)
if (!PartialNetwork && partial)
@@ -440,9 +444,10 @@ CreateWellKnownSockets(void)
DefineSelf (fd);
}
- if (!XFD_ANYSET(&WellKnownConnections))
+ if (!XFD_ANYSET(&WellKnownConnections) && !NoListenAll)
FatalError
("Cannot establish any listening sockets - Make sure an X server isn't already running");
+
#if !defined(WIN32)
OsSignal(SIGPIPE, SIG_IGN);
OsSignal(SIGHUP, AutoResetServer);
@@ -1253,8 +1258,7 @@ MakeClientGrabPervious(ClientPtr client)
}
}
-#ifdef XQUARTZ
-/* Add a fd (from launchd) to our listeners */
+/* Add a fd (from launchd or similar) to our listeners */
void
ListenOnOpenFD(int fd, int noxauth)
{
@@ -1276,7 +1280,7 @@ ListenOnOpenFD(int fd, int noxauth)
*/
ciptr = _XSERVTransReopenCOTSServer(5, fd, port);
if (ciptr == NULL) {
- ErrorF("Got NULL while trying to Reopen launchd port.\n");
+ ErrorF("Got NULL while trying to Reopen listen port.\n");
return;
}
@@ -1309,4 +1313,29 @@ ListenOnOpenFD(int fd, int noxauth)
#endif
}
-#endif
+/* based on TRANS(SocketUNIXAccept) (XtransConnInfo ciptr, int *status) */
+Bool
+AddClientOnOpenFD(int fd)
+{
+ XtransConnInfo ciptr;
+ CARD32 connect_time;
+ char port[20];
+
+ snprintf(port, sizeof(port), ":%d", atoi(display));
+ ciptr = _XSERVTransReopenCOTSServer(5, fd, port);
+ if (ciptr == NULL)
+ return FALSE;
+
+ _XSERVTransSetOption(ciptr, TRANS_NONBLOCKING, 1);
+ ciptr->flags |= TRANS_NOXAUTH;
+
+ connect_time = GetTimeInMillis();
+
+ if (!AllocNewConnection(ciptr, fd, connect_time)) {
+ ErrorConnMax(ciptr);
+ _XSERVTransClose(ciptr);
+ return FALSE;
+ }
+
+ return TRUE;
+}
diff --git a/xorg-server/os/utils.c b/xorg-server/os/utils.c
index 497779b52..c513968ad 100644
--- a/xorg-server/os/utils.c
+++ b/xorg-server/os/utils.c
@@ -270,7 +270,7 @@ LockServer(void)
int len;
char port[20];
- if (nolock)
+ if (nolock || NoListenAll)
return;
/*
* Path names
@@ -390,7 +390,7 @@ LockServer(void)
void
UnlockServer(void)
{
- if (nolock)
+ if (nolock || NoListenAll)
return;
if (!StillLocking) {
diff --git a/xorg-server/test/Makefile.am b/xorg-server/test/Makefile.am
index f8aa65950..88fb6aa96 100644
--- a/xorg-server/test/Makefile.am
+++ b/xorg-server/test/Makefile.am
@@ -30,7 +30,6 @@ endif
xkb_LDADD=$(TEST_LDADD)
input_LDADD=$(TEST_LDADD)
xtest_LDADD=$(TEST_LDADD)
-list_LDADD=$(TEST_LDADD)
misc_LDADD=$(TEST_LDADD)
fixes_LDADD=$(TEST_LDADD)
xfree86_LDADD=$(TEST_LDADD)
diff --git a/xorg-server/xkb/xkbUtils.c b/xorg-server/xkb/xkbUtils.c
index 6cf6e79df..c14a790df 100644
--- a/xorg-server/xkb/xkbUtils.c
+++ b/xorg-server/xkb/xkbUtils.c
@@ -2027,6 +2027,12 @@ XkbDeviceApplyKeymap(DeviceIntPtr dst, XkbDescPtr desc)
return ret;
}
+Bool
+XkbCopyDeviceKeymap(DeviceIntPtr dst, DeviceIntPtr src)
+{
+ return XkbDeviceApplyKeymap(dst, src->key->xkbInfo->desc);
+}
+
int
XkbGetEffectiveGroup(XkbSrvInfoPtr xkbi, XkbStatePtr xkbState, CARD8 keycode)
{