Merge remote-tracking branch 'origin/released'

Conflicts:
	apps/xwininfo/configure.ac
	apps/xwininfo/xwininfo.c
	fontconfig/src/fcmatch.c
	mesalib/include/GL/internal/dri_interface.h
	mesalib/src/glsl/main.cpp
	mesalib/src/mesa/main/pack.c
	mesalib/src/mesa/main/renderbuffer.c
	mesalib/src/mesa/main/renderbuffer.h
	mesalib/src/mesa/main/teximage.c
	mesalib/src/mesa/state_tracker/st_cb_texture.c
	mesalib/src/mesa/state_tracker/st_draw.c
	mesalib/src/mesa/state_tracker/st_format.c
	pixman/configure.ac
	pixman/pixman/pixman-arm-neon-asm.S
	pixman/test/blitters-test.c

23 files changed, 5714 insertions, 5593 deletions

diff --git a/apps/xwininfo/configure.ac b/apps/xwininfo/configure.ac
index 84aef776d..8ff876e09 100644
--- a/apps/xwininfo/configure.ac
+++ b/apps/xwininfo/configure.ac
@@ -60,7 +60,7 @@ AC_MSG_RESULT([$with_xcb_icccm])
 if test "x$with_xcb_icccm" != xno ; then

 	AC_DEFINE([USE_XCB_ICCCM], 1,

 		  [Define to 1 to call xcb-icccm library functions instead of local replacements])

-	xcb_icccm_pc="xcb-icccm"

+	xcb_icccm_pc='xcb-icccm >= 0.3.8'

 fi

 

 # Checks for pkg-config packages

diff --git a/apps/xwininfo/dsimple.c b/apps/xwininfo/dsimple.c
index 63260661c..8a5d7cbeb 100644
--- a/apps/xwininfo/dsimple.c
+++ b/apps/xwininfo/dsimple.c
@@ -237,7 +237,7 @@ struct wininfo_cookies {
 };
 
 #ifndef USE_XCB_ICCCM
-# define xcb_get_wm_name(Dpy, Win) \
+# define xcb_icccm_get_wm_name(Dpy, Win) \
     xcb_get_property (Dpy, False, Win, XCB_ATOM_WM_NAME, \
 		      XCB_GET_PROPERTY_TYPE_ANY, 0, BUFSIZ)
 #endif
@@ -292,17 +292,17 @@ recursive_Window_With_Name  (
 	xcb_discard_reply (dpy, cookies->get_wm_name.sequence);
     } else {
 #ifdef USE_XCB_ICCCM
-	xcb_get_text_property_reply_t nameprop;
+	xcb_icccm_get_text_property_reply_t nameprop;
 
-	if (xcb_get_wm_name_reply (dpy, cookies->get_wm_name,
-				   &nameprop, &err)) {
+	if (xcb_icccm_get_wm_name_reply (dpy, cookies->get_wm_name,
+					 &nameprop, &err)) {
 	    /* can't use strcmp, since nameprop.name is not null terminated */
 	    if ((namelen == nameprop.name_len) &&
 		memcmp (nameprop.name, name, namelen) == 0) {
 		w = window;
 	    }
 
-	    xcb_get_text_property_reply_wipe (&nameprop);
+	    xcb_icccm_get_text_property_reply_wipe (&nameprop);
 	}
 #else
 	prop = xcb_get_property_reply (dpy, cookies->get_wm_name, &err);
@@ -352,7 +352,7 @@ recursive_Window_With_Name  (
 	if (atom_net_wm_name && atom_utf8_string)
 	    child_cookies[i].get_net_wm_name =
 		xcb_get_net_wm_name (dpy, children[i]);
-	child_cookies[i].get_wm_name = xcb_get_wm_name (dpy, children[i]);
+	child_cookies[i].get_wm_name = xcb_icccm_get_wm_name (dpy, children[i]);
 	child_cookies[i].query_tree = xcb_query_tree (dpy, children[i]);
     }
     xcb_flush (dpy);
@@ -394,7 +394,7 @@ Window_With_Name (
 
     if (atom_net_wm_name && atom_utf8_string)
 	cookies.get_net_wm_name = xcb_get_net_wm_name (dpy, top);
-    cookies.get_wm_name = xcb_get_wm_name (dpy, top);
+    cookies.get_wm_name = xcb_icccm_get_wm_name (dpy, top);
     cookies.query_tree = xcb_query_tree (dpy, top);
     xcb_flush (dpy);
     return recursive_Window_With_Name(dpy, top, &cookies, name, strlen(name));
diff --git a/apps/xwininfo/xwininfo.c b/apps/xwininfo/xwininfo.c
index e3960bbee..bb9469956 100644
--- a/apps/xwininfo/xwininfo.c
+++ b/apps/xwininfo/xwininfo.c
@@ -146,49 +146,50 @@ typedef struct {
   xcb_window_t window_group;

 } wm_hints_t;

 

-#define xcb_wm_hints_t wm_hints_t

+#define xcb_icccm_wm_hints_t wm_hints_t

 

 enum {

   /* xcb_size_hints_flags_t */

-  XCB_SIZE_HINT_US_POSITION = 1 << 0,

-  XCB_SIZE_HINT_US_SIZE = 1 << 1,

-  XCB_SIZE_HINT_P_POSITION = 1 << 2,

-  XCB_SIZE_HINT_P_SIZE = 1 << 3,

-  XCB_SIZE_HINT_P_MIN_SIZE = 1 << 4,

-  XCB_SIZE_HINT_P_MAX_SIZE = 1 << 5,

-  XCB_SIZE_HINT_P_RESIZE_INC = 1 << 6,

-  XCB_SIZE_HINT_P_ASPECT = 1 << 7,

-  XCB_SIZE_HINT_BASE_SIZE = 1 << 8,

-  XCB_SIZE_HINT_P_WIN_GRAVITY = 1 << 9,

+  XCB_ICCCM_SIZE_HINT_US_POSITION = 1 << 0,

+  XCB_ICCCM_SIZE_HINT_US_SIZE = 1 << 1,

+  XCB_ICCCM_SIZE_HINT_P_POSITION = 1 << 2,

+  XCB_ICCCM_SIZE_HINT_P_SIZE = 1 << 3,

+  XCB_ICCCM_SIZE_HINT_P_MIN_SIZE = 1 << 4,

+  XCB_ICCCM_SIZE_HINT_P_MAX_SIZE = 1 << 5,

+  XCB_ICCCM_SIZE_HINT_P_RESIZE_INC = 1 << 6,

+  XCB_ICCCM_SIZE_HINT_P_ASPECT = 1 << 7,

+  XCB_ICCCM_SIZE_HINT_BASE_SIZE = 1 << 8,

+  XCB_ICCCM_SIZE_HINT_P_WIN_GRAVITY = 1 << 9,

   /* xcb_wm_state_t */

-  XCB_WM_STATE_WITHDRAWN = 0,

-  XCB_WM_STATE_NORMAL = 1,

-  XCB_WM_STATE_ICONIC = 3,

+  XCB_ICCCM_WM_STATE_WITHDRAWN = 0,

+  XCB_ICCCM_WM_STATE_NORMAL = 1,

+  XCB_ICCCM_WM_STATE_ICONIC = 3,

   /* xcb_wm_t */

-  XCB_WM_HINT_INPUT = (1L << 0),

-  XCB_WM_HINT_STATE = (1L << 1),

-  XCB_WM_HINT_ICON_PIXMAP = (1L << 2),

-  XCB_WM_HINT_ICON_WINDOW = (1L << 3),

-  XCB_WM_HINT_ICON_POSITION = (1L << 4),

-  XCB_WM_HINT_ICON_MASK = (1L << 5),

-  XCB_WM_HINT_WINDOW_GROUP = (1L << 6),

-  XCB_WM_HINT_X_URGENCY = (1L << 8)

+  XCB_ICCCM_WM_HINT_INPUT = (1L << 0),

+  XCB_ICCCM_WM_HINT_STATE = (1L << 1),

+  XCB_ICCCM_WM_HINT_ICON_PIXMAP = (1L << 2),

+  XCB_ICCCM_WM_HINT_ICON_WINDOW = (1L << 3),

+  XCB_ICCCM_WM_HINT_ICON_POSITION = (1L << 4),

+  XCB_ICCCM_WM_HINT_ICON_MASK = (1L << 5),

+  XCB_ICCCM_WM_HINT_WINDOW_GROUP = (1L << 6),

+  XCB_ICCCM_WM_HINT_X_URGENCY = (1L << 8)

 };

 

 /* Once xcb-icccm's API is stable, these should be replaced by calls to it */

 # define GET_TEXT_PROPERTY(Dpy, Win, Atom) \

     xcb_get_property (Dpy, False, Win, Atom, XCB_GET_PROPERTY_TYPE_ANY, 0, BUFSIZ)

-# define xcb_get_wm_name(Dpy, Win)	GET_TEXT_PROPERTY(Dpy, Win, XCB_ATOM_WM_NAME)

+# define xcb_icccm_get_wm_name(Dpy, Win) \

+    GET_TEXT_PROPERTY(Dpy, Win, XCB_ATOM_WM_NAME)

 

-# define xcb_get_wm_class(Dpy, Win) \

+# define xcb_icccm_get_wm_class(Dpy, Win) \

     xcb_get_property (Dpy, False, Win, XCB_ATOM_WM_CLASS, XCB_ATOM_STRING, 0, BUFSIZ)

-# define xcb_get_wm_hints(Dpy, Win) \

+# define xcb_icccm_get_wm_hints(Dpy, Win) \

     xcb_get_property(Dpy, False, Win, XCB_ATOM_WM_HINTS, XCB_ATOM_WM_HINTS, 0, 9)

 

-# define xcb_get_wm_size_hints(Dpy, Win, Atom) \

+# define xcb_icccm_get_wm_size_hints(Dpy, Win, Atom) \

     xcb_get_property (Dpy, False, Win, Atom, XCB_ATOM_WM_SIZE_HINTS, 0, 18)

-# define xcb_get_wm_normal_hints(Dpy, Win) \

-    xcb_get_wm_size_hints(Dpy, Win, XCB_ATOM_WM_NORMAL_HINTS)

+# define xcb_icccm_get_wm_normal_hints(Dpy, Win) \

+    xcb_icccm_get_wm_size_hints(Dpy, Win, XCB_ATOM_WM_NORMAL_HINTS)

 #endif

 

 /* Possibly in xcb-emwh in the future? */

@@ -598,7 +599,7 @@ main (int argc, char **argv)
     /* Send requests to prefetch data we'll need */

     w->window = window;

     w->net_wm_name_cookie = get_net_wm_name (dpy, window);

-    w->wm_name_cookie = xcb_get_wm_name (dpy, window);

+    w->wm_name_cookie = xcb_icccm_get_wm_name (dpy, window);

     if (children || tree)

 	w->tree_cookie = xcb_query_tree (dpy, window);

     if (stats) {

@@ -610,9 +611,9 @@ main (int argc, char **argv)
     if (stats || bits || events)

 	w->attr_cookie = xcb_get_window_attributes (dpy, window);

     if (stats || size)

-	w->normal_hints_cookie = xcb_get_wm_normal_hints (dpy, window);

+	w->normal_hints_cookie = xcb_icccm_get_wm_normal_hints (dpy, window);

     if (wm) {

-	w->hints_cookie = xcb_get_wm_hints(dpy, window);

+	w->hints_cookie = xcb_icccm_get_wm_hints(dpy, window);

 

 	atom_net_wm_desktop = Get_Atom (dpy, "_NET_WM_DESKTOP");

 	if (atom_net_wm_desktop) {

@@ -653,8 +654,8 @@ main (int argc, char **argv)
 	}

     }

     if (size)

-	w->zoom_cookie = xcb_get_wm_size_hints (dpy, window,

-						XCB_ATOM_WM_ZOOM_HINTS);

+	w->zoom_cookie = xcb_icccm_get_wm_size_hints (dpy, window,

+						      XCB_ATOM_WM_ZOOM_HINTS);

     xcb_flush (dpy);

 

     printf ("\nxwininfo: Window id: ");

@@ -727,8 +728,8 @@ wm_size_hints_reply (xcb_connection_t *dpy, xcb_get_property_cookie_t cookie,
     return True;

 }

 

-#define xcb_get_wm_normal_hints_reply wm_size_hints_reply

-#define xcb_get_wm_size_hints_reply wm_size_hints_reply

+#define xcb_icccm_get_wm_normal_hints_reply wm_size_hints_reply

+#define xcb_icccm_get_wm_size_hints_reply wm_size_hints_reply

 #endif

 

 

@@ -740,8 +741,8 @@ fetch_normal_hints (struct wininfo *w, xcb_size_hints_t *hints_return)
     xcb_size_hints_t hints;

 

     if (!w->normal_hints) {

-	if (xcb_get_wm_normal_hints_reply (dpy, w->normal_hints_cookie,

-					   &hints, NULL)) {

+	if (xcb_icccm_get_wm_normal_hints_reply (dpy, w->normal_hints_cookie,

+						 &hints, NULL)) {

 	    w->normal_hints = malloc (sizeof(xcb_size_hints_t));

 	    if (w->normal_hints)

 		memcpy(w->normal_hints, &hints, sizeof(xcb_size_hints_t));

@@ -796,7 +797,7 @@ static void
 Display_Window_Id (struct wininfo *w, Bool newline_wanted)

 {

 #ifdef USE_XCB_ICCCM

-    xcb_get_text_property_reply_t wmn_reply;

+    xcb_icccm_get_text_property_reply_t wmn_reply;

     uint8_t got_reply = False;

 #endif

     xcb_get_property_reply_t *prop;

@@ -820,8 +821,8 @@ Display_Window_Id (struct wininfo *w, Bool newline_wanted)
 	    wm_name_encoding = prop->type;

 	} else { /* No _NET_WM_NAME, check WM_NAME */

 #ifdef USE_XCB_ICCCM

-	    got_reply = xcb_get_wm_name_reply (dpy, w->wm_name_cookie,

-					       &wmn_reply, NULL);

+	    got_reply = xcb_icccm_get_wm_name_reply (dpy, w->wm_name_cookie,

+						     &wmn_reply, NULL);

 	    if (got_reply) {

 		wm_name = wmn_reply.name;

 		wm_name_len = wmn_reply.name_len;

@@ -856,7 +857,7 @@ Display_Window_Id (struct wininfo *w, Bool newline_wanted)
 	}

 #ifdef USE_XCB_ICCCM

 	if (got_reply)

-	    xcb_get_text_property_reply_wipe (&wmn_reply);

+	    xcb_icccm_get_text_property_reply_wipe (&wmn_reply);

 #else

 	free (prop);

 #endif

@@ -1021,10 +1022,11 @@ Display_Stats_Info (struct wininfo *w)
     if (!fetch_normal_hints (w, &hints))

 	hints.flags = 0;

 

-    if ((hints.flags & XCB_SIZE_HINT_P_RESIZE_INC)  &&

+    if ((hints.flags & XCB_ICCCM_SIZE_HINT_P_RESIZE_INC)  &&

 	(hints.width_inc != 0)  && (hints.height_inc != 0)) {

-	if (hints.flags & (XCB_SIZE_HINT_BASE_SIZE|XCB_SIZE_HINT_P_MIN_SIZE)) {

-	    if (hints.flags & XCB_SIZE_HINT_BASE_SIZE) {

+	if (hints.flags &

+	    (XCB_ICCCM_SIZE_HINT_BASE_SIZE|XCB_ICCCM_SIZE_HINT_P_MIN_SIZE)) {

+	    if (hints.flags & XCB_ICCCM_SIZE_HINT_BASE_SIZE) {

 		w->geometry->width -= hints.base_width;

 		w->geometry->height -= hints.base_height;

 	    } else {

@@ -1038,7 +1040,7 @@ Display_Stats_Info (struct wininfo *w)
     } else

 	printf ("%dx%d", w->geometry->width, w->geometry->height);

 

-    if (!(hints.flags & XCB_SIZE_HINT_P_WIN_GRAVITY))

+    if (!(hints.flags & XCB_ICCCM_SIZE_HINT_P_WIN_GRAVITY))

 	hints.win_gravity = XCB_GRAVITY_NORTH_WEST; /* per ICCCM */

     /* find our window manager frame, if any */

     for (wmframe = parent = w->window; parent != 0 ; wmframe = parent) {

@@ -1285,10 +1287,10 @@ display_tree_info_1 (struct wininfo *w, int recurse, int level)
 	struct wininfo rw, pw;

 	rw.window = tree->root;

 	rw.net_wm_name_cookie = get_net_wm_name (dpy, rw.window);

-	rw.wm_name_cookie = xcb_get_wm_name (dpy, rw.window);

+	rw.wm_name_cookie = xcb_icccm_get_wm_name (dpy, rw.window);

 	pw.window = tree->parent;

 	pw.net_wm_name_cookie = get_net_wm_name (dpy, pw.window);

-	pw.wm_name_cookie = xcb_get_wm_name (dpy, pw.window);

+	pw.wm_name_cookie = xcb_icccm_get_wm_name (dpy, pw.window);

 	xcb_flush (dpy);

 

 	printf ("\n");

@@ -1320,8 +1322,8 @@ display_tree_info_1 (struct wininfo *w, int recurse, int level)
 

 	    cw->window = child_list[i];

 	    cw->net_wm_name_cookie = get_net_wm_name (dpy, child_list[i]);

-	    cw->wm_name_cookie = xcb_get_wm_name (dpy, child_list[i]);

-	    cw->wm_class_cookie = xcb_get_wm_class (dpy, child_list[i]);

+	    cw->wm_name_cookie = xcb_icccm_get_wm_name (dpy, child_list[i]);

+	    cw->wm_class_cookie = xcb_icccm_get_wm_class (dpy, child_list[i]);

 	    cw->geometry_cookie = xcb_get_geometry (dpy, child_list[i]);

 	    cw->trans_coords_cookie = xcb_translate_coordinates

 		(dpy, child_list[i], tree->root, 0, 0);

@@ -1336,7 +1338,7 @@ display_tree_info_1 (struct wininfo *w, int recurse, int level)
 	    char *instance_name = NULL, *class_name = NULL;

 	    int instance_name_len, class_name_len;

 #ifdef USE_XCB_ICCCM

-	    xcb_get_wm_class_reply_t classhint;

+	    xcb_icccm_get_wm_class_reply_t classhint;

 #else

 	    xcb_get_property_reply_t *classprop;

 #endif

@@ -1348,7 +1350,7 @@ display_tree_info_1 (struct wininfo *w, int recurse, int level)
 	    printf (": (");

 

 #ifdef USE_XCB_ICCCM

-	    if (xcb_get_wm_class_reply (dpy, cw->wm_class_cookie,

+	    if (xcb_icccm_get_wm_class_reply (dpy, cw->wm_class_cookie,

 					&classhint, NULL)) {

 		got_wm_class = True;

 		instance_name = classhint.instance_name;

@@ -1391,7 +1393,7 @@ display_tree_info_1 (struct wininfo *w, int recurse, int level)
 		    printf ("(none)) ");

 

 #ifdef USE_XCB_ICCCM

-		xcb_get_wm_class_reply_wipe (&classhint);

+		xcb_icccm_get_wm_class_reply_wipe (&classhint);

 #else

 		free (classprop);

 #endif

@@ -1447,68 +1449,68 @@ Display_Hints (xcb_size_hints_t *hints)
 

     flags = hints->flags;

 

-    if (flags & XCB_SIZE_HINT_US_POSITION)

+    if (flags & XCB_ICCCM_SIZE_HINT_US_POSITION)

 	printf ("      User supplied location: %s, %s\n",

 		xscale (hints->x), yscale (hints->y));

 

-    if (flags & XCB_SIZE_HINT_P_POSITION)

+    if (flags & XCB_ICCCM_SIZE_HINT_P_POSITION)

 	printf ("      Program supplied location: %s, %s\n",

 		xscale (hints->x), yscale (hints->y));

 

-    if (flags & XCB_SIZE_HINT_US_SIZE) {

+    if (flags & XCB_ICCCM_SIZE_HINT_US_SIZE) {

 	printf ("      User supplied size: %s by %s\n",

 		xscale (hints->width), yscale (hints->height));

     }

 

-    if (flags & XCB_SIZE_HINT_P_SIZE)

+    if (flags & XCB_ICCCM_SIZE_HINT_P_SIZE)

 	printf ("      Program supplied size: %s by %s\n",

 		xscale (hints->width), yscale (hints->height));

 

-    if (flags & XCB_SIZE_HINT_P_MIN_SIZE)

+    if (flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE)

 	printf ("      Program supplied minimum size: %s by %s\n",

 		xscale (hints->min_width), yscale (hints->min_height));

 

-    if (flags & XCB_SIZE_HINT_P_MAX_SIZE)

+    if (flags & XCB_ICCCM_SIZE_HINT_P_MAX_SIZE)

 	printf ("      Program supplied maximum size: %s by %s\n",

 		xscale (hints->max_width), yscale (hints->max_height));

 

-    if (flags & XCB_SIZE_HINT_BASE_SIZE) {

+    if (flags & XCB_ICCCM_SIZE_HINT_BASE_SIZE) {

 	printf ("      Program supplied base size: %s by %s\n",

 		xscale (hints->base_width), yscale (hints->base_height));

     }

 

-    if (flags & XCB_SIZE_HINT_P_RESIZE_INC) {

+    if (flags & XCB_ICCCM_SIZE_HINT_P_RESIZE_INC) {

 	printf ("      Program supplied x resize increment: %s\n",

 		xscale (hints->width_inc));

 	printf ("      Program supplied y resize increment: %s\n",

 		yscale (hints->height_inc));

 	if (hints->width_inc != 0 && hints->height_inc != 0) {

-	    if (flags & XCB_SIZE_HINT_US_SIZE)

+	    if (flags & XCB_ICCCM_SIZE_HINT_US_SIZE)

 		printf ("      User supplied size in resize increments:  %s by %s\n",

 			(xscale (hints->width / hints->width_inc)),

 			(yscale (hints->height / hints->height_inc)));

-	    if (flags & XCB_SIZE_HINT_P_SIZE)

+	    if (flags & XCB_ICCCM_SIZE_HINT_P_SIZE)

 		printf ("      Program supplied size in resize increments:  %s by %s\n",

 			(xscale (hints->width / hints->width_inc)),

 			(yscale (hints->height / hints->height_inc)));

-	    if (flags & XCB_SIZE_HINT_P_MIN_SIZE)

+	    if (flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE)

 		printf ("      Program supplied minimum size in resize increments: %s by %s\n",

 			xscale (hints->min_width / hints->width_inc), yscale (hints->min_height / hints->height_inc));

-	    if (flags & XCB_SIZE_HINT_BASE_SIZE)

+	    if (flags & XCB_ICCCM_SIZE_HINT_BASE_SIZE)

 		printf ("      Program supplied base size in resize increments:  %s by %s\n",

 			(xscale (hints->base_width / hints->width_inc)),

 			(yscale (hints->base_height / hints->height_inc)));

 	}

     }

 

-    if (flags & XCB_SIZE_HINT_P_ASPECT) {

+    if (flags & XCB_ICCCM_SIZE_HINT_P_ASPECT) {

 	printf ("      Program supplied min aspect ratio: %s/%s\n",

 		xscale (hints->min_aspect_num), yscale (hints->min_aspect_den));

 	printf ("      Program supplied max aspect ratio: %s/%s\n",

 		xscale (hints->max_aspect_num), yscale (hints->max_aspect_den));

     }

 

-    if (flags & XCB_SIZE_HINT_P_WIN_GRAVITY) {

+    if (flags & XCB_ICCCM_SIZE_HINT_P_WIN_GRAVITY) {

 	printf ("      Program supplied window gravity: %s\n",

 		Lookup (hints->win_gravity, _gravities));

     }

@@ -1531,7 +1533,7 @@ Display_Size_Hints (struct wininfo *w)
 	Display_Hints (&hints);

     }

 

-    if (!xcb_get_wm_size_hints_reply (dpy, w->zoom_cookie, &hints, NULL))

+    if (!xcb_icccm_get_wm_size_hints_reply (dpy, w->zoom_cookie, &hints, NULL))

 	printf ("  No zoom window size hints defined\n");

     else {

 	printf ("  Zoom window size hints:\n");

@@ -1598,9 +1600,9 @@ Display_Window_Shape (xcb_window_t window)
  *   window, hints_cookie

  */

 static const binding _state_hints[] = {

-	{ XCB_WM_STATE_WITHDRAWN, "Withdrawn State" },

-	{ XCB_WM_STATE_NORMAL, "Normal State" },

-	{ XCB_WM_STATE_ICONIC, "Iconic State" },

+	{ XCB_ICCCM_WM_STATE_WITHDRAWN, "Withdrawn State" },

+	{ XCB_ICCCM_WM_STATE_NORMAL, "Normal State" },

+	{ XCB_ICCCM_WM_STATE_ICONIC, "Iconic State" },

 /* xwininfo previously also reported the ZoomState & InactiveState,

    but ICCCM declared those obsolete long ago */

 	{ 0, NULL } };

@@ -1629,19 +1631,19 @@ wm_hints_reply (xcb_connection_t *dpy, xcb_get_property_cookie_t cookie,
     return True;

 }

 

-#define xcb_get_wm_hints_reply wm_hints_reply

+#define xcb_icccm_get_wm_hints_reply wm_hints_reply

 #endif

 

 static void

 Display_WM_Info (struct wininfo *w)

 {

-    xcb_wm_hints_t wmhints;

+    xcb_icccm_wm_hints_t wmhints;

     long flags;

     xcb_get_property_reply_t *prop;

     int i;

 

     printf ("\n");

-    if (!xcb_get_wm_hints_reply(dpy, w->hints_cookie, &wmhints, &err))

+    if (!xcb_icccm_get_wm_hints_reply(dpy, w->hints_cookie, &wmhints, &err))

     {

 	printf ("  No window manager hints defined\n");

 	if (err)

@@ -1652,25 +1654,25 @@ Display_WM_Info (struct wininfo *w)
 

     printf ("  Window manager hints:\n");

 

-    if (flags & XCB_WM_HINT_INPUT)

+    if (flags & XCB_ICCCM_WM_HINT_INPUT)

 	printf ("      Client accepts input or input focus: %s\n",

 		Lookup (wmhints.input, _bool));

 

-    if (flags & XCB_WM_HINT_ICON_WINDOW) {

+    if (flags & XCB_ICCCM_WM_HINT_ICON_WINDOW) {

 	struct wininfo iw;

 	iw.window = wmhints.icon_window;

 	iw.net_wm_name_cookie = get_net_wm_name (dpy, iw.window);

-	iw.wm_name_cookie = xcb_get_wm_name (dpy, iw.window);

+	iw.wm_name_cookie = xcb_icccm_get_wm_name (dpy, iw.window);

 

 	printf ("      Icon window id: ");

 	Display_Window_Id (&iw, True);

     }

 

-    if (flags & XCB_WM_HINT_ICON_POSITION)

+    if (flags & XCB_ICCCM_WM_HINT_ICON_POSITION)

 	printf ("      Initial icon position: %s, %s\n",

 		xscale (wmhints.icon_x), yscale (wmhints.icon_y));

 

-    if (flags & XCB_WM_HINT_STATE)

+    if (flags & XCB_ICCCM_WM_HINT_STATE)

 	printf ("      Initial state is %s\n",

 		Lookup (wmhints.initial_state, _state_hints));

 

diff --git a/fontconfig/src/fcmatch.c b/fontconfig/src/fcmatch.c
index 6103ae2c9..c6bb11ef2 100644
--- a/fontconfig/src/fcmatch.c
+++ b/fontconfig/src/fcmatch.c
@@ -749,7 +749,7 @@ FcFontSetSort (FcConfig	    *config,
 	 * If this node matches any language, go check

 	 * which ones and satisfy those entries

 	 */

-	if (nodeps[f]->score[MATCH_LANG_INDEX] < 200)

+	if (nodeps[f]->score[MATCH_LANG_INDEX] < 2000)

 	{

 	    for (i = 0; i < nPatternLang; i++)

 	    {

diff --git a/mesalib/Makefile b/mesalib/Makefile
index 281af3512..131e57872 100644
--- a/mesalib/Makefile
+++ b/mesalib/Makefile
@@ -345,6 +345,16 @@ EGL_FILES = \
 	$(DIRECTORY)/src/egl/main/*.pc.in				\
 	$(DIRECTORY)/src/egl/main/*.def
 
+GBM_FILES = \
+	$(DIRECTORY)/src/gbm/Makefile					\
+	$(DIRECTORY)/src/gbm/main/*.pc.in				\
+	$(DIRECTORY)/src/gbm/main/*.[ch]				\
+	$(DIRECTORY)/src/gbm/main/Makefile				\
+	$(DIRECTORY)/src/gbm/backends/Makefile				\
+	$(DIRECTORY)/src/gbm/backends/Makefile.template			\
+	$(DIRECTORY)/src/gbm/backends/*/*.[ch]				\
+	$(DIRECTORY)/src/gbm/backends/*/Makefile			\
+
 GALLIUM_FILES = \
 	$(DIRECTORY)/src/mesa/state_tracker/*[ch]			\
 	$(DIRECTORY)/src/gallium/Makefile				\
@@ -442,6 +452,7 @@ LIB_FILES = \
 	$(MAPI_FILES)		\
 	$(ES_FILES)		\
 	$(EGL_FILES)		\
+	$(GBM_FILES)		\
 	$(GALLIUM_FILES)	\
 	$(DRI_FILES)		\
 	$(SGI_GLU_FILES)	\
diff --git a/mesalib/configs/autoconf.in b/mesalib/configs/autoconf.in
index abc01b1b2..cac4befe9 100644
--- a/mesalib/configs/autoconf.in
+++ b/mesalib/configs/autoconf.in
@@ -75,6 +75,7 @@ GLESv2_LIB = GLESv2
 VG_LIB = OpenVG
 GLAPI_LIB = glapi
 WAYLAND_EGL_LIB = wayland-egl
+GBM_LIB = gbm
 
 # Library names (actual file names)
 GL_LIB_NAME = @GL_LIB_NAME@
@@ -88,6 +89,7 @@ GLESv2_LIB_NAME = @GLESv2_LIB_NAME@
 VG_LIB_NAME = @VG_LIB_NAME@
 GLAPI_LIB_NAME = @GLAPI_LIB_NAME@
 WAYLAND_EGL_LIB_NAME = @WAYLAND_EGL_LIB_NAME@
+GBM_LIB_NAME = @GBM_LIB_NAME@
 
 # Globs used to install the lib and all symlinks
 GL_LIB_GLOB = @GL_LIB_GLOB@
@@ -101,6 +103,7 @@ GLESv2_LIB_GLOB = @GLESv2_LIB_GLOB@
 VG_LIB_GLOB = @VG_LIB_GLOB@
 GLAPI_LIB_GLOB = @GLAPI_LIB_GLOB@
 WAYLAND_EGL_LIB_GLOB = @WAYLAND_EGL_LIB_GLOB@
+GBM_LIB_GLOB = @GBM_LIB_GLOB@
 
 # Directories to build
 LIB_DIR = @LIB_DIR@
@@ -108,6 +111,7 @@ SRC_DIRS = @SRC_DIRS@
 GLU_DIRS = @GLU_DIRS@
 DRIVER_DIRS = @DRIVER_DIRS@
 EGL_DRIVERS_DIRS = @EGL_DRIVERS_DIRS@
+GBM_BACKEND_DIRS = @GBM_BACKEND_DIRS@
 GALLIUM_DIRS = @GALLIUM_DIRS@
 GALLIUM_DRIVERS_DIRS = @GALLIUM_DRIVERS_DIRS@
 GALLIUM_WINSYS_DIRS = @GALLIUM_WINSYS_DIRS@
@@ -147,7 +151,8 @@ GLESv1_CM_LIB_DEPS = $(EXTRA_LIB_PATH) @GLESv1_CM_LIB_DEPS@
 GLESv2_LIB_DEPS = $(EXTRA_LIB_PATH) @GLESv2_LIB_DEPS@
 VG_LIB_DEPS = $(EXTRA_LIB_PATH) @VG_LIB_DEPS@
 GLAPI_LIB_DEPS = $(EXTRA_LIB_PATH) @GLAPI_LIB_DEPS@
-WAYLAND_EGL_LIB_DEPS = $(EXTRA_LIBPATH) @WAYLAND_EGL_LIB_DEPS@
+WAYLAND_EGL_LIB_DEPS = $(EXTRA_LIB_PATH) @WAYLAND_EGL_LIB_DEPS@
+GBM_LIB_DEPS = $(EXTRA_LIB_PATH) @GBM_LIB_DEPS@
 
 # DRI dependencies
 MESA_MODULES = @MESA_MODULES@
@@ -206,6 +211,9 @@ EGL_PC_CFLAGS = @GL_PC_CFLAGS@
 WAYLAND_EGL_PC_REQ_PRIV = @WAYLAND_EGL_PC_REQ_PRIV@
 WAYLAND_EGL_PC_LIB_PRIV = @WAYLAND_EGL_PC_LIB_PRIV@
 WAYLAND_EGL_PC_CFLAGS = @WAYLAND_EGL_PC_CFLAGS@
+GBM_PC_REQ_PRIV = @GBM_PC_REQ_PRIV@
+GBM_PC_LIB_PRIV = @GBM_PC_LIB_PRIV@
+GBM_PC_CFLAGS = @GBM_PC_CFLAGS@
 
 XCB_DRI2_CFLAGS = @XCB_DRI2_CFLAGS@
 XCB_DRI2_LIBS = @XCB_DRI2_LIBS@
diff --git a/mesalib/configs/default b/mesalib/configs/default
index 393366307..e9f493a17 100644
--- a/mesalib/configs/default
+++ b/mesalib/configs/default
@@ -1,193 +1,205 @@
-# Default/template configuration

-

-# This is included by other config files which may override some

-# of these variables.

-# Think of this as a base class from which configs are derived.

-

-

-CONFIG_NAME = default

-

-# Version info

-MESA_MAJOR=7

-MESA_MINOR=11

-MESA_TINY=0

-MESA_VERSION = $(MESA_MAJOR).$(MESA_MINOR).$(MESA_TINY)

-

-# external projects.  This should be useless now that we use libdrm.

-DRM_SOURCE_PATH=$(TOP)/../drm

-

-# Compiler and flags

-CC = cc

-CXX = CC

-HOST_CC = $(CC)

-CFLAGS = -O

-CXXFLAGS = -O

-LDFLAGS =

-HOST_CFLAGS = $(CFLAGS)

-GLU_CFLAGS = 

-GLX_TLS = no

-

-# Compiler for building demos/tests/etc

-APP_CC = $(CC)

-APP_CXX = $(CXX)

-

-# Misc tools and flags

-SHELL = /bin/sh

-MKLIB = $(SHELL) $(TOP)/bin/mklib

-MKLIB_OPTIONS = 

-MKDEP = makedepend

-MKDEP_OPTIONS = -fdepend

-MAKE = make

-FLEX = flex

-BISON = bison

-

-# Use MINSTALL for installing libraries, INSTALL for everything else

-MINSTALL = $(SHELL) $(TOP)/bin/minstall

-INSTALL = $(MINSTALL)

-

-# Tools for regenerating glapi (generally only needed by the developers)

-PYTHON2 = python

-PYTHON_FLAGS = -t -O -O

-INDENT = indent

-INDENT_FLAGS = -i4 -nut -br -brs -npcs -ce -T GLubyte -T GLbyte -T Bool

-

-# Library names (base name)

-GL_LIB = GL

-GLU_LIB = GLU

-GLUT_LIB = glut

-GLW_LIB = GLw

-OSMESA_LIB = OSMesa

-EGL_LIB = EGL

-GLESv1_CM_LIB = GLESv1_CM

-GLESv2_LIB = GLESv2

-VG_LIB = OpenVG

-GLAPI_LIB = glapi

-WAYLAND_EGL_LIB = wayland-egl

-

-

-# Library names (actual file names)

-GL_LIB_NAME = lib$(GL_LIB).so

-GLU_LIB_NAME = lib$(GLU_LIB).so

-GLUT_LIB_NAME = lib$(GLUT_LIB).so

-GLW_LIB_NAME = lib$(GLW_LIB).so

-OSMESA_LIB_NAME = lib$(OSMESA_LIB).so

-EGL_LIB_NAME = lib$(EGL_LIB).so

-GLESv1_CM_LIB_NAME = lib$(GLESv1_CM_LIB).so

-GLESv2_LIB_NAME = lib$(GLESv2_LIB).so

-VG_LIB_NAME = lib$(VG_LIB).so

-GLAPI_LIB_NAME = lib$(GLAPI_LIB).so

-WAYLAND_EGL_LIB_NAME = lib$(WAYLAND_EGL_LIB).so

-

-# globs used to install the lib and all symlinks

-GL_LIB_GLOB = $(GL_LIB_NAME)*

-GLU_LIB_GLOB = $(GLU_LIB_NAME)*

-GLUT_LIB_GLOB = $(GLUT_LIB_NAME)*

-GLW_LIB_GLOB = $(GLW_LIB_NAME)*

-OSMESA_LIB_GLOB = $(OSMESA_LIB_NAME)*

-EGL_LIB_GLOB = $(EGL_LIB_NAME)*

-GLESv1_CM_LIB_GLOB = $(GLESv1_CM_LIB_NAME)*

-GLESv2_LIB_GLOB = $(GLESv2_LIB_NAME)*

-VG_LIB_GLOB = $(VG_LIB_NAME)*

-GLAPI_LIB_GLOB = $(GLAPI_LIB_NAME)*

-WAYLAND_EGL_LIB_GLOB = $(WAYLAND_EGL_LIB_NAME)*

-

-DRI_CFLAGS = $(CFLAGS)

-DRI_CXXFLAGS = $(CXXFLAGS)

-

-# Optional assembly language optimization files for libGL

-MESA_ASM_SOURCES = 

-

-# GLw widget sources (Append "GLwMDrawA.c" here and add -lXm to GLW_LIB_DEPS in

-# order to build the Motif widget too)

-GLW_SOURCES = GLwDrawA.c

-MOTIF_CFLAGS = -I/usr/include/Motif1.2

-

-

-# Directories to build

-LIB_DIR = lib

-SRC_DIRS = glsl mapi/glapi mapi/vgapi mesa \

-	gallium egl gallium/winsys gallium/targets glu glut/glx glw

-GLU_DIRS = sgi

-DRIVER_DIRS = x11 osmesa

-

-# EGL drivers to build

-EGL_DRIVERS_DIRS = glx

-

-# Gallium directories and 

-GALLIUM_DIRS = auxiliary drivers state_trackers

-GALLIUM_AUXILIARIES = $(TOP)/src/gallium/auxiliary/libgallium.a

-GALLIUM_DRIVERS_DIRS = softpipe trace rbug noop identity galahad i915 i965 svga r300 nvfx nv50 failover

-GALLIUM_DRIVERS = $(foreach DIR,$(GALLIUM_DRIVERS_DIRS),$(TOP)/src/gallium/drivers/$(DIR)/lib$(DIR).a)

-GALLIUM_WINSYS_DIRS = sw sw/xlib

-GALLIUM_TARGET_DIRS = libgl-xlib

-GALLIUM_STATE_TRACKERS_DIRS = glx vega

-

-# native platforms EGL should support

-EGL_PLATFORMS = x11

-EGL_CLIENT_APIS = $(GL_LIB)

-

-# Library dependencies

-#EXTRA_LIB_PATH ?=

-GL_LIB_DEPS     = $(EXTRA_LIB_PATH) -lX11 -lXext -lm -lpthread

-EGL_LIB_DEPS    = $(EXTRA_LIB_PATH) -ldl -lpthread

-OSMESA_LIB_DEPS = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GL_LIB)

-GLU_LIB_DEPS    = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GL_LIB) -lm

-GLUT_LIB_DEPS   = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GLU_LIB) -l$(GL_LIB) -lX11 -lXmu -lXi -lm

-GLW_LIB_DEPS    = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GL_LIB) -lXt -lX11

-APP_LIB_DEPS    = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GLUT_LIB) -l$(GLU_LIB) -l$(GL_LIB) -lm

-GLESv1_CM_LIB_DEPS = $(EXTRA_LIB_PATH) -lpthread

-GLESv2_LIB_DEPS = $(EXTRA_LIB_PATH) -lpthread

-VG_LIB_DEPS    = $(EXTRA_LIB_PATH) -lpthread

-GLAPI_LIB_DEPS = $(EXTRA_LIB_PATH) -lpthread

-WAYLAND_EGL_LIB_DEPS = $(EXTRA_LIB_PATH) -lwayland-client -ldrm

-

-# Program dependencies - specific GL/glut libraries added in Makefiles

-APP_LIB_DEPS = -lm

-X11_LIBS = -lX11

-

-DLOPEN_LIBS = -ldl

-

-# Installation directories (for make install)

-INSTALL_DIR = /usr/local

-INSTALL_LIB_DIR = $(INSTALL_DIR)/$(LIB_DIR)

-INSTALL_INC_DIR = $(INSTALL_DIR)/include

-DRI_DRIVER_INSTALL_DIR = $(INSTALL_LIB_DIR)/dri

-

-# Where libGL will look for DRI hardware drivers

-DRI_DRIVER_SEARCH_DIR = $(DRI_DRIVER_INSTALL_DIR)

-

-# EGL driver install directory

-EGL_DRIVER_INSTALL_DIR = $(INSTALL_LIB_DIR)/egl

-

-# Xorg driver install directory (for xorg state-tracker)

-XORG_DRIVER_INSTALL_DIR = $(INSTALL_LIB_DIR)/xorg/modules/drivers

-

-# pkg-config substitutions

-GL_PC_REQ_PRIV =

-GL_PC_LIB_PRIV =

-GL_PC_CFLAGS =

-DRI_PC_REQ_PRIV =

-GLU_PC_REQ = gl

-GLU_PC_REQ_PRIV =

-GLU_PC_LIB_PRIV =

-GLU_PC_CFLAGS =

-GLUT_PC_REQ_PRIV =

-GLUT_PC_LIB_PRIV =

-GLUT_PC_CFLAGS =

-GLW_PC_REQ_PRIV =

-GLW_PC_LIB_PRIV =

-GLW_PC_CFLAGS =

-OSMESA_PC_REQ =

-OSMESA_PC_LIB_PRIV =

-GLESv1_CM_PC_REQ_PRIV =

-GLESv1_CM_PC_LIB_PRIV =

-GLESv1_CM_PC_CFLAGS =

-GLESv2_PC_REQ_PRIV =

-GLESv2_PC_LIB_PRIV =

-GLESv2_PC_CFLAGS =

-VG_PC_REQ_PRIV =

-VG_PC_LIB_PRIV =

-VG_PC_CFLAGS =

-WAYLAND_EGL_PC_REQ_PRIV =

-WAYLAND_EGL_PC_LIB_PRIV =

-WAYLAND_EGL_PC_CFLAGS =

+# Default/template configuration
+
+# This is included by other config files which may override some
+# of these variables.
+# Think of this as a base class from which configs are derived.
+
+
+CONFIG_NAME = default
+
+# Version info
+MESA_MAJOR=7
+MESA_MINOR=11
+MESA_TINY=0
+MESA_VERSION = $(MESA_MAJOR).$(MESA_MINOR).$(MESA_TINY)
+
+# external projects.  This should be useless now that we use libdrm.
+DRM_SOURCE_PATH=$(TOP)/../drm
+
+# Compiler and flags
+CC = cc
+CXX = CC
+HOST_CC = $(CC)
+CFLAGS = -O
+CXXFLAGS = -O
+LDFLAGS =
+HOST_CFLAGS = $(CFLAGS)
+GLU_CFLAGS = 
+GLX_TLS = no
+
+# Compiler for building demos/tests/etc
+APP_CC = $(CC)
+APP_CXX = $(CXX)
+
+# Misc tools and flags
+SHELL = /bin/sh
+MKLIB = $(SHELL) $(TOP)/bin/mklib
+MKLIB_OPTIONS = 
+MKDEP = makedepend
+MKDEP_OPTIONS = -fdepend
+MAKE = make
+FLEX = flex
+BISON = bison
+
+# Use MINSTALL for installing libraries, INSTALL for everything else
+MINSTALL = $(SHELL) $(TOP)/bin/minstall
+INSTALL = $(MINSTALL)
+
+# Tools for regenerating glapi (generally only needed by the developers)
+PYTHON2 = python
+PYTHON_FLAGS = -t -O -O
+INDENT = indent
+INDENT_FLAGS = -i4 -nut -br -brs -npcs -ce -T GLubyte -T GLbyte -T Bool
+
+# Library names (base name)
+GL_LIB = GL
+GLU_LIB = GLU
+GLUT_LIB = glut
+GLW_LIB = GLw
+OSMESA_LIB = OSMesa
+EGL_LIB = EGL
+GLESv1_CM_LIB = GLESv1_CM
+GLESv2_LIB = GLESv2
+VG_LIB = OpenVG
+GLAPI_LIB = glapi
+WAYLAND_EGL_LIB = wayland-egl
+GBM_LIB = gbm
+
+# Library names (actual file names)
+GL_LIB_NAME = lib$(GL_LIB).so
+GLU_LIB_NAME = lib$(GLU_LIB).so
+GLUT_LIB_NAME = lib$(GLUT_LIB).so
+GLW_LIB_NAME = lib$(GLW_LIB).so
+OSMESA_LIB_NAME = lib$(OSMESA_LIB).so
+EGL_LIB_NAME = lib$(EGL_LIB).so
+GLESv1_CM_LIB_NAME = lib$(GLESv1_CM_LIB).so
+GLESv2_LIB_NAME = lib$(GLESv2_LIB).so
+VG_LIB_NAME = lib$(VG_LIB).so
+GLAPI_LIB_NAME = lib$(GLAPI_LIB).so
+WAYLAND_EGL_LIB_NAME = lib$(WAYLAND_EGL_LIB).so
+GBM_LIB_NAME = lib$(GBM_LIB).so
+
+# globs used to install the lib and all symlinks
+GL_LIB_GLOB = $(GL_LIB_NAME)*
+GLU_LIB_GLOB = $(GLU_LIB_NAME)*
+GLUT_LIB_GLOB = $(GLUT_LIB_NAME)*
+GLW_LIB_GLOB = $(GLW_LIB_NAME)*
+OSMESA_LIB_GLOB = $(OSMESA_LIB_NAME)*
+EGL_LIB_GLOB = $(EGL_LIB_NAME)*
+GLESv1_CM_LIB_GLOB = $(GLESv1_CM_LIB_NAME)*
+GLESv2_LIB_GLOB = $(GLESv2_LIB_NAME)*
+VG_LIB_GLOB = $(VG_LIB_NAME)*
+GLAPI_LIB_GLOB = $(GLAPI_LIB_NAME)*
+WAYLAND_EGL_LIB_GLOB = $(WAYLAND_EGL_LIB_NAME)*
+GBM_LIB_GLOB = $(GBM_LIB_NAME)*
+
+DRI_CFLAGS = $(CFLAGS)
+DRI_CXXFLAGS = $(CXXFLAGS)
+
+# Optional assembly language optimization files for libGL
+MESA_ASM_SOURCES = 
+
+# GLw widget sources (Append "GLwMDrawA.c" here and add -lXm to GLW_LIB_DEPS in
+# order to build the Motif widget too)
+GLW_SOURCES = GLwDrawA.c
+MOTIF_CFLAGS = -I/usr/include/Motif1.2
+
+
+# Directories to build
+LIB_DIR = lib
+SRC_DIRS = glsl mapi/glapi mapi/vgapi mesa \
+	gallium egl gallium/winsys gallium/targets glu glut/glx glw
+GLU_DIRS = sgi
+DRIVER_DIRS = x11 osmesa
+
+# EGL drivers to build
+EGL_DRIVERS_DIRS = glx
+
+# gbm backends to build
+GBM_BACKEND_DIRS = dri
+
+# Gallium directories and 
+GALLIUM_DIRS = auxiliary drivers state_trackers
+GALLIUM_AUXILIARIES = $(TOP)/src/gallium/auxiliary/libgallium.a
+GALLIUM_DRIVERS_DIRS = softpipe trace rbug noop identity galahad i915 i965 svga r300 nvfx nv50 failover
+GALLIUM_DRIVERS = $(foreach DIR,$(GALLIUM_DRIVERS_DIRS),$(TOP)/src/gallium/drivers/$(DIR)/lib$(DIR).a)
+GALLIUM_WINSYS_DIRS = sw sw/xlib
+GALLIUM_TARGET_DIRS = libgl-xlib
+GALLIUM_STATE_TRACKERS_DIRS = glx vega
+
+# native platforms EGL should support
+EGL_PLATFORMS = x11
+EGL_CLIENT_APIS = $(GL_LIB)
+
+# Library dependencies
+#EXTRA_LIB_PATH ?=
+GL_LIB_DEPS     = $(EXTRA_LIB_PATH) -lX11 -lXext -lm -lpthread
+EGL_LIB_DEPS    = $(EXTRA_LIB_PATH) -ldl -lpthread
+OSMESA_LIB_DEPS = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GL_LIB)
+GLU_LIB_DEPS    = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GL_LIB) -lm
+GLUT_LIB_DEPS   = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GLU_LIB) -l$(GL_LIB) -lX11 -lXmu -lXi -lm
+GLW_LIB_DEPS    = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GL_LIB) -lXt -lX11
+APP_LIB_DEPS    = $(EXTRA_LIB_PATH) -L$(TOP)/$(LIB_DIR) -l$(GLUT_LIB) -l$(GLU_LIB) -l$(GL_LIB) -lm
+GLESv1_CM_LIB_DEPS = $(EXTRA_LIB_PATH) -lpthread
+GLESv2_LIB_DEPS = $(EXTRA_LIB_PATH) -lpthread
+VG_LIB_DEPS    = $(EXTRA_LIB_PATH) -lpthread
+GLAPI_LIB_DEPS = $(EXTRA_LIB_PATH) -lpthread
+WAYLAND_EGL_LIB_DEPS = $(EXTRA_LIB_PATH) -lwayland-client -ldrm
+GBM_LIB_DEPS = $(EXTRA_LIB_PATH) -ludev -ldl
+
+# Program dependencies - specific GL/glut libraries added in Makefiles
+APP_LIB_DEPS = -lm
+X11_LIBS = -lX11
+
+DLOPEN_LIBS = -ldl
+
+# Installation directories (for make install)
+INSTALL_DIR = /usr/local
+INSTALL_LIB_DIR = $(INSTALL_DIR)/$(LIB_DIR)
+INSTALL_INC_DIR = $(INSTALL_DIR)/include
+DRI_DRIVER_INSTALL_DIR = $(INSTALL_LIB_DIR)/dri
+
+# Where libGL will look for DRI hardware drivers
+DRI_DRIVER_SEARCH_DIR = $(DRI_DRIVER_INSTALL_DIR)
+
+# EGL driver install directory
+EGL_DRIVER_INSTALL_DIR = $(INSTALL_LIB_DIR)/egl
+
+# gbm backend install directory
+GBM_BACKEND_INSTALL_DIR = $(INSTALL_LIB_DIR)/gbm
+
+# Xorg driver install directory (for xorg state-tracker)
+XORG_DRIVER_INSTALL_DIR = $(INSTALL_LIB_DIR)/xorg/modules/drivers
+
+# pkg-config substitutions
+GL_PC_REQ_PRIV =
+GL_PC_LIB_PRIV =
+GL_PC_CFLAGS =
+DRI_PC_REQ_PRIV =
+GLU_PC_REQ = gl
+GLU_PC_REQ_PRIV =
+GLU_PC_LIB_PRIV =
+GLU_PC_CFLAGS =
+GLUT_PC_REQ_PRIV =
+GLUT_PC_LIB_PRIV =
+GLUT_PC_CFLAGS =
+GLW_PC_REQ_PRIV =
+GLW_PC_LIB_PRIV =
+GLW_PC_CFLAGS =
+OSMESA_PC_REQ =
+OSMESA_PC_LIB_PRIV =
+GLESv1_CM_PC_REQ_PRIV =
+GLESv1_CM_PC_LIB_PRIV =
+GLESv1_CM_PC_CFLAGS =
+GLESv2_PC_REQ_PRIV =
+GLESv2_PC_LIB_PRIV =
+GLESv2_PC_CFLAGS =
+VG_PC_REQ_PRIV =
+VG_PC_LIB_PRIV =
+VG_PC_CFLAGS =
+WAYLAND_EGL_PC_REQ_PRIV =
+WAYLAND_EGL_PC_LIB_PRIV =
+WAYLAND_EGL_PC_CFLAGS =
+GBM_PC_REQ_PRIV =
+GBM_PC_LIB_PRIV =
+GBM_PC_CFLAGS =
diff --git a/mesalib/configure.ac b/mesalib/configure.ac
index c9dd8a70c..0346a8ade 100644
--- a/mesalib/configure.ac
+++ b/mesalib/configure.ac
@@ -352,6 +352,7 @@ GLESv2_LIB_NAME='lib$(GLESv2_LIB).'${LIB_EXTENSION}
 VG_LIB_NAME='lib$(VG_LIB).'${LIB_EXTENSION}
 GLAPI_LIB_NAME='lib$(GLAPI_LIB).'${LIB_EXTENSION}
 WAYLAND_EGL_LIB_NAME='lib$(WAYLAND_EGL_LIB).'${LIB_EXTENSION}
+GBM_LIB_NAME='lib$(GBM_LIB).'${LIB_EXTENSION}
 
 GL_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GL_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'
 GLU_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GLU_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'
@@ -365,6 +366,7 @@ GLESv2_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GLESv2_LIB)'${LIB_VERSION_SEPARATOR}'*'${LI
 VG_LIB_GLOB=${LIB_PREFIX_GLOB}'$(VG_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'
 GLAPI_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GLAPI_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'
 WAYLAND_EGL_LIB_GLOB=${LIB_PREFIX_GLOB}'$(WAYLAND_EGL_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'
+GBM_LIB_GLOB=${LIB_PREFIX_GLOB}'$(GBM_LIB)'${LIB_VERSION_SEPARATOR}'*'${LIB_EXTENSION}'*'
 
 AC_SUBST([GL_LIB_NAME])
 AC_SUBST([GLU_LIB_NAME])
@@ -377,6 +379,7 @@ AC_SUBST([GLESv2_LIB_NAME])
 AC_SUBST([VG_LIB_NAME])
 AC_SUBST([GLAPI_LIB_NAME])
 AC_SUBST([WAYLAND_EGL_LIB_NAME])
+AC_SUBST([GBM_LIB_NAME])
 
 AC_SUBST([GL_LIB_GLOB])
 AC_SUBST([GLU_LIB_GLOB])
@@ -389,6 +392,7 @@ AC_SUBST([GLESv2_LIB_GLOB])
 AC_SUBST([VG_LIB_GLOB])
 AC_SUBST([GLAPI_LIB_GLOB])
 AC_SUBST([WAYLAND_EGL_LIB_GLOB])
+AC_SUBST([GBM_LIB_GLOB])
 
 dnl
 dnl Arch/platform-specific settings
@@ -543,6 +547,11 @@ AC_ARG_ENABLE([egl],
         [disable EGL library @<:@default=enabled@:>@])],
     [enable_egl="$enableval"],
     [enable_egl=yes])
+AC_ARG_ENABLE([gbm],
+   [AS_HELP_STRING([--enable-gbm],
+         [enable gbm library @<:@default=auto@:>@])],
+   [enable_gbm="$enableval"],
+   [enable_gbm=auto])
 AC_ARG_ENABLE([gallium_egl],
     [AS_HELP_STRING([--enable-gallium-egl],
         [enable optional EGL state tracker (not required
@@ -550,6 +559,13 @@ AC_ARG_ENABLE([gallium_egl],
          @<:@default=disable@:>@])],
     [enable_gallium_egl="$enableval"],
     [enable_gallium_egl=no])
+AC_ARG_ENABLE([gallium_gbm],
+    [AS_HELP_STRING([--enable-gallium-gbm],
+        [enable optional gbm state tracker (not required for
+         gbm support in Gallium)
+         @<:@default=disable@:>@])],
+    [enable_gallium_gbm="$enableval"],
+    [enable_gallium_gbm=no])
 
 # Option for Gallium drivers
 GALLIUM_DRIVERS_DEFAULT="r300,r600,swrast"
@@ -1245,6 +1261,41 @@ AC_SUBST([EGL_LIB_DEPS])
 AC_SUBST([EGL_DRIVERS_DIRS])
 
 dnl
+dnl gbm configuration
+dnl
+if test "x$enable_gbm" = xauto; then
+    case "$with_egl_platforms" in
+        *drm*)
+            enable_gbm=yes ;;
+         *)
+            enable_gbm=no ;;
+    esac
+fi
+if test "x$enable_gbm" = xyes; then
+    SRC_DIRS="$SRC_DIRS gbm"
+    GBM_BACKEND_DIRS=""
+
+    PKG_CHECK_MODULES([LIBUDEV], [libudev], [],
+                      AC_MSG_ERROR([gbm needs udev]))
+    GBM_LIB_DEPS="$DLOPEN_LIBS $LIBUDEV_LIBS"
+
+    if test "$mesa_driver" = dri; then
+        GBM_BACKEND_DIRS="$GBM_BACKEND_DIRS dri"
+        if test "$SHARED_GLAPI" -eq 0; then
+            AC_MSG_ERROR([gbm_dri requires --enable-shared-glapi])
+        fi
+    fi
+fi
+AC_SUBST([GBM_LIB_DEPS])
+AC_SUBST([GBM_BACKEND_DIRS])
+GBM_PC_REQ_PRIV="libudev"
+GBM_PC_LIB_PRIV="$DLOPEN_LIBS"
+GBM_PC_CFLAGS=
+AC_SUBST([GBM_PC_REQ_PRIV])
+AC_SUBST([GBM_PC_LIB_PRIV])
+AC_SUBST([GBM_PC_CFLAGS])
+
+dnl
 dnl EGL Gallium configuration
 dnl
 if test "x$enable_gallium_egl" = xyes; then
@@ -1256,11 +1307,27 @@ if test "x$enable_gallium_egl" = xyes; then
     fi
 
     GALLIUM_STATE_TRACKERS_DIRS="egl $GALLIUM_STATE_TRACKERS_DIRS"
-    GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS egl"
+    GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS egl-static"
     HAVE_ST_EGL="yes"
 fi
 
 dnl
+dnl gbm Gallium configuration
+dnl
+if test "x$enable_gallium_gbm" = xyes; then
+    if test "x$with_gallium_drivers" = x; then
+        AC_MSG_ERROR([cannot enable gbm_gallium without Gallium])
+    fi
+    if test "x$enable_gbm" = xno; then
+        AC_MSG_ERROR([cannot enable gbm_gallium without gbm])
+    fi
+
+    GALLIUM_STATE_TRACKERS_DIRS="gbm $GALLIUM_STATE_TRACKERS_DIRS"
+    GALLIUM_TARGET_DIRS="$GALLIUM_TARGET_DIRS gbm"
+    HAVE_ST_GBM="yes"
+fi
+
+dnl
 dnl X.Org DDX configuration
 dnl
 if test "x$enable_xorg" = xyes; then
@@ -1563,9 +1630,6 @@ case "$with_egl_platforms" in
 yes)
     if test "x$enable_egl" = xyes && test "x$mesa_driver" != xosmesa; then
         EGL_PLATFORMS="x11"
-        if test "$mesa_driver" = dri; then
-            EGL_PLATFORMS="$EGL_PLATFORMS drm"
-        fi
     fi
     ;;
 *)
@@ -1586,6 +1650,9 @@ yes)
 		WAYLAND_EGL_LIB_DEPS="$WAYLAND_LIBS $LIBDRM_LIBS"
                 GALLIUM_WINSYS_DIRS="$GALLIUM_WINSYS_DIRS sw/wayland"
 	fi
+        if test "$plat" = "drm" && test "x$enable_gbm" = no; then
+                AC_MSG_ERROR([EGL platform drm needs gbm])
+        fi
     done
     EGL_PLATFORMS="$egl_platforms"
     ;;
@@ -1747,6 +1814,12 @@ fi
 ln -s autoconf configs/current
 ])
 
+dnl Sort the dirs alphabetically
+GALLIUM_TARGET_DIRS=`echo $GALLIUM_TARGET_DIRS|tr " " "\n"|sort|tr "\n" " "`
+GALLIUM_WINSYS_DIRS=`echo $GALLIUM_WINSYS_DIRS|tr " " "\n"|sort|tr "\n" " "`
+GALLIUM_DRIVERS_DIRS=`echo $GALLIUM_DRIVERS_DIRS|tr " " "\n"|sort|tr "\n" " "`
+GALLIUM_STATE_TRACKERS_DIRS=`echo $GALLIUM_STATE_TRACKERS_DIRS|tr " " "\n"|sort|tr "\n" " "`
+
 AC_OUTPUT
 
 dnl
diff --git a/mesalib/include/EGL/eglplatform.h b/mesalib/include/EGL/eglplatform.h
index e4aa0994b..fbfdce32e 100644
--- a/mesalib/include/EGL/eglplatform.h
+++ b/mesalib/include/EGL/eglplatform.h
@@ -84,6 +84,12 @@ typedef struct wl_display     *EGLNativeDisplayType;
 typedef struct wl_egl_pixmap  *EGLNativePixmapType;
 typedef struct wl_egl_window  *EGLNativeWindowType;
 
+#elif defined(__GBM__)
+
+typedef struct gbm_device  *EGLNativeDisplayType;
+typedef struct gbm_bo      *EGLNativePixmapType;
+typedef void               *EGLNativeWindowType;
+
 #elif defined(__unix__) || defined(__unix)
 
 #ifdef MESA_EGL_NO_X11_HEADERS
diff --git a/mesalib/include/GL/internal/dri_interface.h b/mesalib/include/GL/internal/dri_interface.h
index 2132277f0..7b9de0359 100644
--- a/mesalib/include/GL/internal/dri_interface.h
+++ b/mesalib/include/GL/internal/dri_interface.h
@@ -851,6 +851,11 @@ struct __DRIimageExtensionRec {
 			       void *loaderPrivate);

 

    GLboolean (*queryImage)(__DRIimage *image, int attrib, int *value);

+

+   /**

+    * The new __DRIimage will share the content with the old one, see dup(2).

+    */

+   __DRIimage *(*dupImage)(__DRIimage *image, void *loaderPrivate);

 };

 

 

diff --git a/mesalib/src/glsl/main.cpp b/mesalib/src/glsl/main.cpp
index 873a4fa16..54c7099f9 100644
--- a/mesalib/src/glsl/main.cpp
+++ b/mesalib/src/glsl/main.cpp
@@ -87,6 +87,7 @@ initialize_context(struct gl_context *ctx, gl_api api)
    ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;

    ctx->Extensions.EXT_texture_array = GL_TRUE;

    ctx->Extensions.NV_texture_rectangle = GL_TRUE;

+   ctx->Extensions.EXT_texture3D = GL_TRUE;

 

    /* GLSL 1.30 isn't fully supported, but we need to advertise 1.30 so that

     * the built-in functions for 1.30 can be built.

diff --git a/mesalib/src/mesa/main/pack.c b/mesalib/src/mesa/main/pack.c
index fcf0f9f53..215bc7ba7 100644
--- a/mesalib/src/mesa/main/pack.c
+++ b/mesalib/src/mesa/main/pack.c
@@ -4683,7 +4683,7 @@ _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
                          GLenum srcType, const GLvoid *source,

                          const struct gl_pixelstore_attrib *srcPacking )

 {

-   GLfloat *depthTemp, *depthValues;

+   GLfloat *depthTemp = NULL, *depthValues;

    GLboolean needClamp = GL_FALSE;

 

    /* Look for special cases first.

@@ -4729,16 +4729,16 @@ _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
 

    /* general case path follows */

 

-   depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));

-   if (!depthTemp) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

-      return;

-   }

-

    if (dstType == GL_FLOAT) {

       depthValues = (GLfloat *) dest;

    }

    else {

+      depthTemp = (GLfloat *) malloc(n * sizeof(GLfloat));

+      if (!depthTemp) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "pixel unpacking");

+         return;

+      }

+

       depthValues = depthTemp;

    }

 

@@ -4782,6 +4782,7 @@ _mesa_unpack_depth_span( struct gl_context *ctx, GLuint n,
                 }

                 zValues[i] = value & 0xffffff00;

             }

+            free(depthTemp);

             return;

          }

          else {

diff --git a/mesalib/src/mesa/main/renderbuffer.c b/mesalib/src/mesa/main/renderbuffer.c
index af3029499..8733853cb 100644
--- a/mesalib/src/mesa/main/renderbuffer.c
+++ b/mesalib/src/mesa/main/renderbuffer.c
@@ -2567,26 +2567,3 @@ _mesa_reference_renderbuffer(struct gl_renderbuffer **ptr,
       *ptr = rb;

    }

 }

-

-

-/**

- * Create a new combined depth/stencil renderbuffer for implementing

- * the GL_EXT_packed_depth_stencil extension.

- * \return new depth/stencil renderbuffer

- */

-struct gl_renderbuffer *

-_mesa_new_depthstencil_renderbuffer(struct gl_context *ctx, GLuint name)

-{

-   struct gl_renderbuffer *dsrb;

-

-   dsrb = _mesa_new_renderbuffer(ctx, name);

-   if (!dsrb)

-      return NULL;

-

-   /* init fields not covered by _mesa_new_renderbuffer() */

-   dsrb->InternalFormat = GL_DEPTH24_STENCIL8_EXT;

-   dsrb->Format = MESA_FORMAT_Z24_S8;

-   dsrb->AllocStorage = _mesa_soft_renderbuffer_storage;

-

-   return dsrb;

-}

diff --git a/mesalib/src/mesa/main/renderbuffer.h b/mesalib/src/mesa/main/renderbuffer.h
index a3a618297..4ac691824 100644
--- a/mesalib/src/mesa/main/renderbuffer.h
+++ b/mesalib/src/mesa/main/renderbuffer.h
@@ -108,8 +108,5 @@ extern void
 _mesa_reference_renderbuffer(struct gl_renderbuffer **ptr,

                              struct gl_renderbuffer *rb);

 

-extern struct gl_renderbuffer *

-_mesa_new_depthstencil_renderbuffer(struct gl_context *ctx, GLuint name);

-

 

 #endif /* RENDERBUFFER_H */

diff --git a/mesalib/src/mesa/main/teximage.c b/mesalib/src/mesa/main/teximage.c
index 61da02f71..7493cd65b 100644
--- a/mesalib/src/mesa/main/teximage.c
+++ b/mesalib/src/mesa/main/teximage.c
@@ -3274,7 +3274,7 @@ compressedteximage(struct gl_context *ctx, GLuint dims,
                                           border, imageSize, &reason);

 

    if (error) {

-      _mesa_error(ctx, error, "glTexImage2D(%s)", reason);

+      _mesa_error(ctx, error, "glCompressedTexImage%uD(%s)", dims, reason);

       return;

    }

 

diff --git a/mesalib/src/mesa/main/texstore.c b/mesalib/src/mesa/main/texstore.c
index ea116a011..5c925a3d3 100644
--- a/mesalib/src/mesa/main/texstore.c
+++ b/mesalib/src/mesa/main/texstore.c
@@ -1,4985 +1,4988 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.5

- *

- * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

- * Copyright (c) 2008-2009  VMware, Inc.

- *

- * 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 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

- * BRIAN PAUL 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:

- *   Brian Paul

- */

-

-/**

- * The GL texture image functions in teximage.c basically just do

- * error checking and data structure allocation.  They in turn call

- * device driver functions which actually copy/convert/store the user's

- * texture image data.

- *

- * However, most device drivers will be able to use the fallback functions

- * in this file.  That is, most drivers will have the following bit of

- * code:

- *   ctx->Driver.TexImage1D = _mesa_store_teximage1d;

- *   ctx->Driver.TexImage2D = _mesa_store_teximage2d;

- *   ctx->Driver.TexImage3D = _mesa_store_teximage3d;

- *   etc...

- *

- * Texture image processing is actually kind of complicated.  We have to do:

- *    Format/type conversions

- *    pixel unpacking

- *    pixel transfer (scale, bais, lookup, etc)

- *

- * These functions can handle most everything, including processing full

- * images and sub-images.

- */

-

-

-#include "glheader.h"

-#include "bufferobj.h"

-#include "colormac.h"

-#include "image.h"

-#include "macros.h"

-#include "mipmap.h"

-#include "mfeatures.h"

-#include "mtypes.h"

-#include "pack.h"

-#include "pbo.h"

-#include "imports.h"

-#include "texcompress.h"

-#include "texcompress_fxt1.h"

-#include "texcompress_rgtc.h"

-#include "texcompress_s3tc.h"

-#include "teximage.h"

-#include "texstore.h"

-#include "enums.h"

-#include "../../gallium/auxiliary/util/u_format_rgb9e5.h"

-#include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"

-

-

-enum {

-   ZERO = 4, 

-   ONE = 5

-};

-

-

-/**

- * Texture image storage function.

- */

-typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);

-

-

-/**

- * Return GL_TRUE if the given image format is one that be converted

- * to another format by swizzling.

- */

-static GLboolean

-can_swizzle(GLenum logicalBaseFormat)

-{

-   switch (logicalBaseFormat) {

-   case GL_RGBA:

-   case GL_RGB:

-   case GL_LUMINANCE_ALPHA:

-   case GL_INTENSITY:

-   case GL_ALPHA:

-   case GL_LUMINANCE:

-   case GL_RED:

-   case GL_GREEN:

-   case GL_BLUE:

-   case GL_BGR:

-   case GL_BGRA:

-   case GL_ABGR_EXT:

-   case GL_RG:

-      return GL_TRUE;

-   default:

-      return GL_FALSE;

-   }

-}

-

-

-

-enum {

-   IDX_LUMINANCE = 0,

-   IDX_ALPHA,

-   IDX_INTENSITY,

-   IDX_LUMINANCE_ALPHA,

-   IDX_RGB,

-   IDX_RGBA,

-   IDX_RED,

-   IDX_GREEN,

-   IDX_BLUE,

-   IDX_BGR,

-   IDX_BGRA,

-   IDX_ABGR,

-   IDX_RG,

-   MAX_IDX

-};

-

-#define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)

-#define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)

-#define MAP3(x,y,z)   MAP4(x, y, z, ZERO)

-#define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }

-

-

-static const struct {

-   GLubyte format_idx;

-   GLubyte to_rgba[6];

-   GLubyte from_rgba[6];

-} mappings[MAX_IDX] = 

-{

-   {

-      IDX_LUMINANCE,

-      MAP4(0,0,0,ONE),

-      MAP1(0)

-   },

-

-   {

-      IDX_ALPHA,

-      MAP4(ZERO, ZERO, ZERO, 0),

-      MAP1(3)

-   },

-

-   {

-      IDX_INTENSITY,

-      MAP4(0, 0, 0, 0),

-      MAP1(0),

-   },

-

-   {

-      IDX_LUMINANCE_ALPHA,

-      MAP4(0,0,0,1),

-      MAP2(0,3)

-   },

-

-   {

-      IDX_RGB,

-      MAP4(0,1,2,ONE),

-      MAP3(0,1,2)

-   },

-

-   {

-      IDX_RGBA,

-      MAP4(0,1,2,3),

-      MAP4(0,1,2,3),

-   },

-

-   {

-      IDX_RED,

-      MAP4(0, ZERO, ZERO, ONE),

-      MAP1(0),

-   },

-

-   {

-      IDX_GREEN,

-      MAP4(ZERO, 0, ZERO, ONE),

-      MAP1(1),

-   },

-

-   {

-      IDX_BLUE,

-      MAP4(ZERO, ZERO, 0, ONE),

-      MAP1(2),

-   },

-

-   {

-      IDX_BGR,

-      MAP4(2,1,0,ONE),

-      MAP3(2,1,0)

-   },

-

-   {

-      IDX_BGRA,

-      MAP4(2,1,0,3),

-      MAP4(2,1,0,3)

-   },

-

-   {

-      IDX_ABGR,

-      MAP4(3,2,1,0),

-      MAP4(3,2,1,0)

-   },

-

-   {

-      IDX_RG,

-      MAP4(0, 1, ZERO, ONE),

-      MAP2(0, 1)

-   },

-};

-

-

-

-/**

- * Convert a GL image format enum to an IDX_* value (see above).

- */

-static int

-get_map_idx(GLenum value)

-{

-   switch (value) {

-   case GL_LUMINANCE: return IDX_LUMINANCE;

-   case GL_ALPHA: return IDX_ALPHA;

-   case GL_INTENSITY: return IDX_INTENSITY;

-   case GL_LUMINANCE_ALPHA: return IDX_LUMINANCE_ALPHA;

-   case GL_RGB: return IDX_RGB;

-   case GL_RGBA: return IDX_RGBA;

-   case GL_RED: return IDX_RED;

-   case GL_GREEN: return IDX_GREEN;

-   case GL_BLUE: return IDX_BLUE;

-   case GL_BGR: return IDX_BGR;

-   case GL_BGRA: return IDX_BGRA;

-   case GL_ABGR_EXT: return IDX_ABGR;

-   case GL_RG: return IDX_RG;

-   default:

-      _mesa_problem(NULL, "Unexpected inFormat");

-      return 0;

-   }

-}   

-

-

-/**

- * When promoting texture formats (see below) we need to compute the

- * mapping of dest components back to source components.

- * This function does that.

- * \param inFormat  the incoming format of the texture

- * \param outFormat  the final texture format

- * \return map[6]  a full 6-component map

- */

-static void

-compute_component_mapping(GLenum inFormat, GLenum outFormat, 

-			  GLubyte *map)

-{

-   const int inFmt = get_map_idx(inFormat);

-   const int outFmt = get_map_idx(outFormat);

-   const GLubyte *in2rgba = mappings[inFmt].to_rgba;

-   const GLubyte *rgba2out = mappings[outFmt].from_rgba;

-   int i;

-   

-   for (i = 0; i < 4; i++)

-      map[i] = in2rgba[rgba2out[i]];

-

-   map[ZERO] = ZERO;

-   map[ONE] = ONE;   

-

-#if 0

-   printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",

-	  inFormat, _mesa_lookup_enum_by_nr(inFormat),

-	  outFormat, _mesa_lookup_enum_by_nr(outFormat),

-	  map[0], 

-	  map[1], 

-	  map[2], 

-	  map[3], 

-	  map[4], 

-	  map[5]); 

-#endif

-}

-

-

-/**

- * Make a temporary (color) texture image with GLfloat components.

- * Apply all needed pixel unpacking and pixel transfer operations.

- * Note that there are both logicalBaseFormat and textureBaseFormat parameters.

- * Suppose the user specifies GL_LUMINANCE as the internal texture format

- * but the graphics hardware doesn't support luminance textures.  So, we might

- * use an RGB hardware format instead.

- * If logicalBaseFormat != textureBaseFormat we have some extra work to do.

- *

- * \param ctx  the rendering context

- * \param dims  image dimensions: 1, 2 or 3

- * \param logicalBaseFormat  basic texture derived from the user's

- *    internal texture format value

- * \param textureBaseFormat  the actual basic format of the texture

- * \param srcWidth  source image width

- * \param srcHeight  source image height

- * \param srcDepth  source image depth

- * \param srcFormat  source image format

- * \param srcType  source image type

- * \param srcAddr  source image address

- * \param srcPacking  source image pixel packing

- * \return resulting image with format = textureBaseFormat and type = GLfloat.

- */

-GLfloat *

-_mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,

-			    GLenum logicalBaseFormat,

-			    GLenum textureBaseFormat,

-			    GLint srcWidth, GLint srcHeight, GLint srcDepth,

-			    GLenum srcFormat, GLenum srcType,

-			    const GLvoid *srcAddr,

-			    const struct gl_pixelstore_attrib *srcPacking,

-			    GLbitfield transferOps)

-{

-   GLfloat *tempImage;

-   const GLint components = _mesa_components_in_format(logicalBaseFormat);

-   const GLint srcStride =

-      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-   GLfloat *dst;

-   GLint img, row;

-

-   ASSERT(dims >= 1 && dims <= 3);

-

-   ASSERT(logicalBaseFormat == GL_RGBA ||

-          logicalBaseFormat == GL_RGB ||

-          logicalBaseFormat == GL_RG ||

-          logicalBaseFormat == GL_RED ||

-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

-          logicalBaseFormat == GL_LUMINANCE ||

-          logicalBaseFormat == GL_ALPHA ||

-          logicalBaseFormat == GL_INTENSITY ||

-          logicalBaseFormat == GL_COLOR_INDEX ||

-          logicalBaseFormat == GL_DEPTH_COMPONENT);

-

-   ASSERT(textureBaseFormat == GL_RGBA ||

-          textureBaseFormat == GL_RGB ||

-          textureBaseFormat == GL_RG ||

-          textureBaseFormat == GL_RED ||

-          textureBaseFormat == GL_LUMINANCE_ALPHA ||

-          textureBaseFormat == GL_LUMINANCE ||

-          textureBaseFormat == GL_ALPHA ||

-          textureBaseFormat == GL_INTENSITY ||

-          textureBaseFormat == GL_COLOR_INDEX ||

-          textureBaseFormat == GL_DEPTH_COMPONENT);

-

-   tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth

-				  * components * sizeof(GLfloat));

-   if (!tempImage)

-      return NULL;

-

-   dst = tempImage;

-   for (img = 0; img < srcDepth; img++) {

-      const GLubyte *src

-	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

-						 srcWidth, srcHeight,

-						 srcFormat, srcType,

-						 img, 0, 0);

-      for (row = 0; row < srcHeight; row++) {

-	 _mesa_unpack_color_span_float(ctx, srcWidth, logicalBaseFormat,

-				       dst, srcFormat, srcType, src,

-				       srcPacking, transferOps);

-	 dst += srcWidth * components;

-	 src += srcStride;

-      }

-   }

-

-   if (logicalBaseFormat != textureBaseFormat) {

-      /* more work */

-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

-      GLfloat *newImage;

-      GLint i, n;

-      GLubyte map[6];

-

-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

-             textureBaseFormat == GL_LUMINANCE_ALPHA);

-

-      /* The actual texture format should have at least as many components

-       * as the logical texture format.

-       */

-      ASSERT(texComponents >= logComponents);

-

-      newImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth

-                                          * texComponents * sizeof(GLfloat));

-      if (!newImage) {

-         free(tempImage);

-         return NULL;

-      }

-

-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

-

-      n = srcWidth * srcHeight * srcDepth;

-      for (i = 0; i < n; i++) {

-         GLint k;

-         for (k = 0; k < texComponents; k++) {

-            GLint j = map[k];

-            if (j == ZERO)

-               newImage[i * texComponents + k] = 0.0F;

-            else if (j == ONE)

-               newImage[i * texComponents + k] = 1.0F;

-            else

-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

-         }

-      }

-

-      free(tempImage);

-      tempImage = newImage;

-   }

-

-   return tempImage;

-}

-

-

-/**

- * Make temporary image with uint pixel values.  Used for unsigned

- * integer-valued textures.

- */

-static GLuint *

-make_temp_uint_image(struct gl_context *ctx, GLuint dims,

-                     GLenum logicalBaseFormat,

-                     GLenum textureBaseFormat,

-                     GLint srcWidth, GLint srcHeight, GLint srcDepth,

-                     GLenum srcFormat, GLenum srcType,

-                     const GLvoid *srcAddr,

-                     const struct gl_pixelstore_attrib *srcPacking)

-{

-   GLuint *tempImage;

-   const GLint components = _mesa_components_in_format(logicalBaseFormat);

-   const GLint srcStride =

-      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-   GLuint *dst;

-   GLint img, row;

-

-   ASSERT(dims >= 1 && dims <= 3);

-

-   ASSERT(logicalBaseFormat == GL_RGBA ||

-          logicalBaseFormat == GL_RGB ||

-          logicalBaseFormat == GL_RG ||

-          logicalBaseFormat == GL_RED ||

-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

-          logicalBaseFormat == GL_LUMINANCE ||

-          logicalBaseFormat == GL_INTENSITY ||

-          logicalBaseFormat == GL_ALPHA);

-

-   ASSERT(textureBaseFormat == GL_RGBA ||

-          textureBaseFormat == GL_RGB ||

-          textureBaseFormat == GL_RG ||

-          textureBaseFormat == GL_RED ||

-          textureBaseFormat == GL_LUMINANCE_ALPHA ||

-          textureBaseFormat == GL_LUMINANCE ||

-          textureBaseFormat == GL_ALPHA);

-

-   tempImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth

-                                 * components * sizeof(GLuint));

-   if (!tempImage)

-      return NULL;

-

-   dst = tempImage;

-   for (img = 0; img < srcDepth; img++) {

-      const GLubyte *src

-	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

-						 srcWidth, srcHeight,

-						 srcFormat, srcType,

-						 img, 0, 0);

-      for (row = 0; row < srcHeight; row++) {

-	 _mesa_unpack_color_span_uint(ctx, srcWidth, logicalBaseFormat,

-                                      dst, srcFormat, srcType, src,

-                                      srcPacking);

-	 dst += srcWidth * components;

-	 src += srcStride;

-      }

-   }

-

-   if (logicalBaseFormat != textureBaseFormat) {

-      /* more work */

-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

-      GLuint *newImage;

-      GLint i, n;

-      GLubyte map[6];

-

-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

-             textureBaseFormat == GL_LUMINANCE_ALPHA);

-

-      /* The actual texture format should have at least as many components

-       * as the logical texture format.

-       */

-      ASSERT(texComponents >= logComponents);

-

-      newImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth

-                                   * texComponents * sizeof(GLuint));

-      if (!newImage) {

-         free(tempImage);

-         return NULL;

-      }

-

-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

-

-      n = srcWidth * srcHeight * srcDepth;

-      for (i = 0; i < n; i++) {

-         GLint k;

-         for (k = 0; k < texComponents; k++) {

-            GLint j = map[k];

-            if (j == ZERO)

-               newImage[i * texComponents + k] = 0.0F;

-            else if (j == ONE)

-               newImage[i * texComponents + k] = 1.0F;

-            else

-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

-         }

-      }

-

-      free(tempImage);

-      tempImage = newImage;

-   }

-

-   return tempImage;

-}

-

-

-

-/**

- * Make a temporary (color) texture image with GLchan components.

- * Apply all needed pixel unpacking and pixel transfer operations.

- * Note that there are both logicalBaseFormat and textureBaseFormat parameters.

- * Suppose the user specifies GL_LUMINANCE as the internal texture format

- * but the graphics hardware doesn't support luminance textures.  So, we might

- * use an RGB hardware format instead.

- * If logicalBaseFormat != textureBaseFormat we have some extra work to do.

- *

- * \param ctx  the rendering context

- * \param dims  image dimensions: 1, 2 or 3

- * \param logicalBaseFormat  basic texture derived from the user's

- *    internal texture format value

- * \param textureBaseFormat  the actual basic format of the texture

- * \param srcWidth  source image width

- * \param srcHeight  source image height

- * \param srcDepth  source image depth

- * \param srcFormat  source image format

- * \param srcType  source image type

- * \param srcAddr  source image address

- * \param srcPacking  source image pixel packing

- * \return resulting image with format = textureBaseFormat and type = GLchan.

- */

-GLchan *

-_mesa_make_temp_chan_image(struct gl_context *ctx, GLuint dims,

-                           GLenum logicalBaseFormat,

-                           GLenum textureBaseFormat,

-                           GLint srcWidth, GLint srcHeight, GLint srcDepth,

-                           GLenum srcFormat, GLenum srcType,

-                           const GLvoid *srcAddr,

-                           const struct gl_pixelstore_attrib *srcPacking)

-{

-   GLuint transferOps = ctx->_ImageTransferState;

-   const GLint components = _mesa_components_in_format(logicalBaseFormat);

-   GLint img, row;

-   GLchan *tempImage, *dst;

-

-   ASSERT(dims >= 1 && dims <= 3);

-

-   ASSERT(logicalBaseFormat == GL_RGBA ||

-          logicalBaseFormat == GL_RGB ||

-          logicalBaseFormat == GL_RG ||

-          logicalBaseFormat == GL_RED ||

-          logicalBaseFormat == GL_LUMINANCE_ALPHA ||

-          logicalBaseFormat == GL_LUMINANCE ||

-          logicalBaseFormat == GL_ALPHA ||

-          logicalBaseFormat == GL_INTENSITY);

-

-   ASSERT(textureBaseFormat == GL_RGBA ||

-          textureBaseFormat == GL_RGB ||

-          textureBaseFormat == GL_RG ||

-          textureBaseFormat == GL_RED ||

-          textureBaseFormat == GL_LUMINANCE_ALPHA ||

-          textureBaseFormat == GL_LUMINANCE ||

-          textureBaseFormat == GL_ALPHA ||

-          textureBaseFormat == GL_INTENSITY);

-

-   /* unpack and transfer the source image */

-   tempImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth

-                                       * components * sizeof(GLchan));

-   if (!tempImage) {

-      return NULL;

-   }

-

-   dst = tempImage;

-   for (img = 0; img < srcDepth; img++) {

-      const GLint srcStride =

-         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-      const GLubyte *src =

-         (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,

-                                               srcWidth, srcHeight,

-                                               srcFormat, srcType,

-                                               img, 0, 0);

-      for (row = 0; row < srcHeight; row++) {

-         _mesa_unpack_color_span_chan(ctx, srcWidth, logicalBaseFormat, dst,

-                                      srcFormat, srcType, src, srcPacking,

-                                      transferOps);

-         dst += srcWidth * components;

-         src += srcStride;

-      }

-   }

-

-   if (logicalBaseFormat != textureBaseFormat) {

-      /* one more conversion step */

-      GLint texComponents = _mesa_components_in_format(textureBaseFormat);

-      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);

-      GLchan *newImage;

-      GLint i, n;

-      GLubyte map[6];

-

-      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */

-      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||

-             textureBaseFormat == GL_LUMINANCE_ALPHA);

-

-      /* The actual texture format should have at least as many components

-       * as the logical texture format.

-       */

-      ASSERT(texComponents >= logComponents);

-

-      newImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth

-                                         * texComponents * sizeof(GLchan));

-      if (!newImage) {

-         free(tempImage);

-         return NULL;

-      }

-

-      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);

-

-      n = srcWidth * srcHeight * srcDepth;

-      for (i = 0; i < n; i++) {

-         GLint k;

-         for (k = 0; k < texComponents; k++) {

-            GLint j = map[k];

-            if (j == ZERO)

-               newImage[i * texComponents + k] = 0;

-            else if (j == ONE)

-               newImage[i * texComponents + k] = CHAN_MAX;

-            else

-               newImage[i * texComponents + k] = tempImage[i * logComponents + j];

-         }

-      }

-

-      free(tempImage);

-      tempImage = newImage;

-   }

-

-   return tempImage;

-}

-

-

-/**

- * Copy GLubyte pixels from <src> to <dst> with swizzling.

- * \param dst  destination pixels

- * \param dstComponents  number of color components in destination pixels

- * \param src  source pixels

- * \param srcComponents  number of color components in source pixels

- * \param map  the swizzle mapping.  map[X] says where to find the X component

- *             in the source image's pixels.  For example, if the source image

- *             is GL_BGRA and X = red, map[0] yields 2.

- * \param count  number of pixels to copy/swizzle.

- */

-static void

-swizzle_copy(GLubyte *dst, GLuint dstComponents, const GLubyte *src, 

-             GLuint srcComponents, const GLubyte *map, GLuint count)

-{

-#define SWZ_CPY(dst, src, count, dstComps, srcComps) \

-   do {                                              \

-      GLuint i;                                      \

-      for (i = 0; i < count; i++) {                  \

-         GLuint j;                                   \

-         if (srcComps == 4) {                        \

-            COPY_4UBV(tmp, src);                     \

-         }                                           \

-         else {                                      \

-            for (j = 0; j < srcComps; j++) {         \

-               tmp[j] = src[j];                      \

-            }                                        \

-         }                                           \

-         src += srcComps;                            \

-         for (j = 0; j < dstComps; j++) {            \

-            dst[j] = tmp[map[j]];                    \

-         }                                           \

-         dst += dstComps;                            \

-      }                                              \

-   } while (0)

-

-   GLubyte tmp[6];

-

-   tmp[ZERO] = 0x0;

-   tmp[ONE] = 0xff;

-

-   ASSERT(srcComponents <= 4);

-   ASSERT(dstComponents <= 4);

-

-   switch (dstComponents) {

-   case 4:

-      switch (srcComponents) {

-      case 4:

-         SWZ_CPY(dst, src, count, 4, 4);

-         break;

-      case 3:

-         SWZ_CPY(dst, src, count, 4, 3);

-         break;

-      case 2:

-         SWZ_CPY(dst, src, count, 4, 2);

-         break;

-      case 1:

-         SWZ_CPY(dst, src, count, 4, 1);

-         break;

-      default:

-         ;

-      }

-      break;

-   case 3:

-      switch (srcComponents) {

-      case 4:

-         SWZ_CPY(dst, src, count, 3, 4);

-         break;

-      case 3:

-         SWZ_CPY(dst, src, count, 3, 3);

-         break;

-      case 2:

-         SWZ_CPY(dst, src, count, 3, 2);

-         break;

-      case 1:

-         SWZ_CPY(dst, src, count, 3, 1);

-         break;

-      default:

-         ;

-      }

-      break;

-   case 2:

-      switch (srcComponents) {

-      case 4:

-         SWZ_CPY(dst, src, count, 2, 4);

-         break;

-      case 3:

-         SWZ_CPY(dst, src, count, 2, 3);

-         break;

-      case 2:

-         SWZ_CPY(dst, src, count, 2, 2);

-         break;

-      case 1:

-         SWZ_CPY(dst, src, count, 2, 1);

-         break;

-      default:

-         ;

-      }

-      break;

-   case 1:

-      switch (srcComponents) {

-      case 4:

-         SWZ_CPY(dst, src, count, 1, 4);

-         break;

-      case 3:

-         SWZ_CPY(dst, src, count, 1, 3);

-         break;

-      case 2:

-         SWZ_CPY(dst, src, count, 1, 2);

-         break;

-      case 1:

-         SWZ_CPY(dst, src, count, 1, 1);

-         break;

-      default:

-         ;

-      }

-      break;

-   default:

-      ;

-   }

-#undef SWZ_CPY

-}

-

-

-

-static const GLubyte map_identity[6] = { 0, 1, 2, 3, ZERO, ONE };

-static const GLubyte map_3210[6] = { 3, 2, 1, 0, ZERO, ONE };

-

-

-/**

- * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a

- * mapping array depending on endianness.

- */

-static const GLubyte *

-type_mapping( GLenum srcType )

-{

-   switch (srcType) {

-   case GL_BYTE:

-   case GL_UNSIGNED_BYTE:

-      return map_identity;

-   case GL_UNSIGNED_INT_8_8_8_8:

-      return _mesa_little_endian() ? map_3210 : map_identity;

-   case GL_UNSIGNED_INT_8_8_8_8_REV:

-      return _mesa_little_endian() ? map_identity : map_3210;

-   default:

-      return NULL;

-   }

-}

-

-

-/**

- * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a

- * mapping array depending on pixelstore byte swapping state.

- */

-static const GLubyte *

-byteswap_mapping( GLboolean swapBytes,

-		  GLenum srcType )

-{

-   if (!swapBytes) 

-      return map_identity;

-

-   switch (srcType) {

-   case GL_BYTE:

-   case GL_UNSIGNED_BYTE:

-      return map_identity;

-   case GL_UNSIGNED_INT_8_8_8_8:

-   case GL_UNSIGNED_INT_8_8_8_8_REV:

-      return map_3210;

-   default:

-      return NULL;

-   }

-}

-

-

-

-/**

- * Transfer a GLubyte texture image with component swizzling.

- */

-static void

-_mesa_swizzle_ubyte_image(struct gl_context *ctx, 

-			  GLuint dimensions,

-			  GLenum srcFormat,

-			  GLenum srcType,

-

-			  GLenum baseInternalFormat,

-

-			  const GLubyte *rgba2dst,

-			  GLuint dstComponents,

-

-			  GLvoid *dstAddr,

-			  GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,

-			  GLint dstRowStride,

-                          const GLuint *dstImageOffsets,

-

-			  GLint srcWidth, GLint srcHeight, GLint srcDepth,

-			  const GLvoid *srcAddr,

-			  const struct gl_pixelstore_attrib *srcPacking )

-{

-   GLint srcComponents = _mesa_components_in_format(srcFormat);

-   const GLubyte *srctype2ubyte, *swap;

-   GLubyte map[4], src2base[6], base2rgba[6];

-   GLint i;

-   const GLint srcRowStride =

-      _mesa_image_row_stride(srcPacking, srcWidth,

-                             srcFormat, GL_UNSIGNED_BYTE);

-   const GLint srcImageStride

-      = _mesa_image_image_stride(srcPacking, srcWidth, srcHeight, srcFormat,

-                                 GL_UNSIGNED_BYTE);

-   const GLubyte *srcImage

-      = (const GLubyte *) _mesa_image_address(dimensions, srcPacking, srcAddr,

-                                              srcWidth, srcHeight, srcFormat,

-                                              GL_UNSIGNED_BYTE, 0, 0, 0);

-

-   (void) ctx;

-

-   /* Translate from src->baseInternal->GL_RGBA->dst.  This will

-    * correctly deal with RGBA->RGB->RGBA conversions where the final

-    * A value must be 0xff regardless of the incoming alpha values.

-    */

-   compute_component_mapping(srcFormat, baseInternalFormat, src2base);

-   compute_component_mapping(baseInternalFormat, GL_RGBA, base2rgba);

-   swap = byteswap_mapping(srcPacking->SwapBytes, srcType);

-   srctype2ubyte = type_mapping(srcType);

-

-

-   for (i = 0; i < 4; i++)

-      map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];

-

-/*    printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]);  */

-

-   if (srcComponents == dstComponents &&

-       srcRowStride == dstRowStride &&

-       srcRowStride == srcWidth * srcComponents &&

-       dimensions < 3) {

-      /* 1 and 2D images only */

-      GLubyte *dstImage = (GLubyte *) dstAddr

-         + dstYoffset * dstRowStride

-         + dstXoffset * dstComponents;

-      swizzle_copy(dstImage, dstComponents, srcImage, srcComponents, map, 

-		   srcWidth * srcHeight);

-   }

-   else {

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         const GLubyte *srcRow = srcImage;

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * dstComponents

-            + dstYoffset * dstRowStride

-            + dstXoffset * dstComponents;

-         for (row = 0; row < srcHeight; row++) {

-	    swizzle_copy(dstRow, dstComponents, srcRow, srcComponents, map, srcWidth);

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-         srcImage += srcImageStride;

-      }

-   }

-}

-

-

-/**

- * Teximage storage routine for when a simple memcpy will do.

- * No pixel transfer operations or special texel encodings allowed.

- * 1D, 2D and 3D images supported.

- */

-static void

-memcpy_texture(struct gl_context *ctx,

-	       GLuint dimensions,

-               gl_format dstFormat,

-               GLvoid *dstAddr,

-               GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,

-               GLint dstRowStride,

-               const GLuint *dstImageOffsets,

-               GLint srcWidth, GLint srcHeight, GLint srcDepth,

-               GLenum srcFormat, GLenum srcType,

-               const GLvoid *srcAddr,

-               const struct gl_pixelstore_attrib *srcPacking)

-{

-   const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,

-                                                     srcFormat, srcType);

-   const GLint srcImageStride = _mesa_image_image_stride(srcPacking,

-                                      srcWidth, srcHeight, srcFormat, srcType);

-   const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dimensions,

-        srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLint bytesPerRow = srcWidth * texelBytes;

-

-#if 0

-   /* XXX update/re-enable for dstImageOffsets array */

-   const GLint bytesPerImage = srcHeight * bytesPerRow;

-   const GLint bytesPerTexture = srcDepth * bytesPerImage;

-   GLubyte *dstImage = (GLubyte *) dstAddr

-                     + dstZoffset * dstImageStride

-                     + dstYoffset * dstRowStride

-                     + dstXoffset * texelBytes;

-

-   if (dstRowStride == srcRowStride &&

-       dstRowStride == bytesPerRow &&

-       ((dstImageStride == srcImageStride &&

-         dstImageStride == bytesPerImage) ||

-        (srcDepth == 1))) {

-      /* one big memcpy */

-      ctx->Driver.TextureMemCpy(dstImage, srcImage, bytesPerTexture);

-   }

-   else

-   {

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         const GLubyte *srcRow = srcImage;

-         GLubyte *dstRow = dstImage;

-         for (row = 0; row < srcHeight; row++) {

-            ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-         srcImage += srcImageStride;

-         dstImage += dstImageStride;

-      }

-   }

-#endif

-

-   GLint img, row;

-   for (img = 0; img < srcDepth; img++) {

-      const GLubyte *srcRow = srcImage;

-      GLubyte *dstRow = (GLubyte *) dstAddr

-         + dstImageOffsets[dstZoffset + img] * texelBytes

-         + dstYoffset * dstRowStride

-         + dstXoffset * texelBytes;

-      for (row = 0; row < srcHeight; row++) {

-         ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);

-         dstRow += dstRowStride;

-         srcRow += srcRowStride;

-      }

-      srcImage += srcImageStride;

-   }

-}

-

-

-

-/**

- * Store a 32-bit integer depth component texture image.

- */

-static GLboolean

-_mesa_texstore_z32(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffffff;

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   (void) dims;

-   ASSERT(dstFormat == MESA_FORMAT_Z32);

-   ASSERT(texelBytes == sizeof(GLuint));

-

-   if (ctx->Pixel.DepthScale == 1.0f &&

-       ctx->Pixel.DepthBias == 0.0f &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_DEPTH_COMPONENT &&

-       srcFormat == GL_DEPTH_COMPONENT &&

-       srcType == GL_UNSIGNED_INT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            _mesa_unpack_depth_span(ctx, srcWidth,

-                                    GL_UNSIGNED_INT, (GLuint *) dstRow,

-                                    depthScale, srcType, src, srcPacking);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a 24-bit integer depth component texture image.

- */

-static GLboolean

-_mesa_texstore_x8_z24(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffff;

-   const GLuint texelBytes = 4;

-

-   (void) dims;

-   ASSERT(dstFormat == MESA_FORMAT_X8_Z24);

-

-   {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            _mesa_unpack_depth_span(ctx, srcWidth,

-                                    GL_UNSIGNED_INT, (GLuint *) dstRow,

-                                    depthScale, srcType, src, srcPacking);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a 24-bit integer depth component texture image.

- */

-static GLboolean

-_mesa_texstore_z24_x8(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffff;

-   const GLuint texelBytes = 4;

-

-   (void) dims;

-   ASSERT(dstFormat == MESA_FORMAT_Z24_X8);

-

-   {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            GLuint *dst = (GLuint *) dstRow;

-            GLint i;

-            _mesa_unpack_depth_span(ctx, srcWidth,

-                                    GL_UNSIGNED_INT, dst,

-                                    depthScale, srcType, src, srcPacking);

-            for (i = 0; i < srcWidth; i++)

-               dst[i] <<= 8;

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a 16-bit integer depth component texture image.

- */

-static GLboolean

-_mesa_texstore_z16(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffff;

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   (void) dims;

-   ASSERT(dstFormat == MESA_FORMAT_Z16);

-   ASSERT(texelBytes == sizeof(GLushort));

-

-   if (ctx->Pixel.DepthScale == 1.0f &&

-       ctx->Pixel.DepthBias == 0.0f &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_DEPTH_COMPONENT &&

-       srcFormat == GL_DEPTH_COMPONENT &&

-       srcType == GL_UNSIGNED_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            GLushort *dst16 = (GLushort *) dstRow;

-            _mesa_unpack_depth_span(ctx, srcWidth,

-                                    GL_UNSIGNED_SHORT, dst16, depthScale,

-                                    srcType, src, srcPacking);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store an rgb565 or rgb565_rev texture image.

- */

-static GLboolean

-_mesa_texstore_rgb565(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGB565 ||

-          dstFormat == MESA_FORMAT_RGB565_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_RGB565 &&

-       baseInternalFormat == GL_RGB &&

-       srcFormat == GL_RGB &&

-       srcType == GL_UNSIGNED_SHORT_5_6_5) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-            baseInternalFormat == GL_RGB &&

-            srcFormat == GL_RGB &&

-            srcType == GL_UNSIGNED_BYTE &&

-            dims == 2) {

-      /* do optimized tex store */

-      const GLint srcRowStride =

-         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-      const GLubyte *src = (const GLubyte *)

-         _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,

-                             srcFormat, srcType, 0, 0, 0);

-      GLubyte *dst = (GLubyte *) dstAddr

-                   + dstYoffset * dstRowStride

-                   + dstXoffset * texelBytes;

-      GLint row, col;

-      for (row = 0; row < srcHeight; row++) {

-         const GLubyte *srcUB = (const GLubyte *) src;

-         GLushort *dstUS = (GLushort *) dst;

-         /* check for byteswapped format */

-         if (dstFormat == MESA_FORMAT_RGB565) {

-            for (col = 0; col < srcWidth; col++) {

-               dstUS[col] = PACK_COLOR_565( srcUB[0], srcUB[1], srcUB[2] );

-               srcUB += 3;

-            }

-         }

-         else {

-            for (col = 0; col < srcWidth; col++) {

-               dstUS[col] = PACK_COLOR_565_REV( srcUB[0], srcUB[1], srcUB[2] );

-               srcUB += 3;

-            }

-         }

-         dst += dstRowStride;

-         src += srcRowStride;

-      }

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            /* check for byteswapped format */

-            if (dstFormat == MESA_FORMAT_RGB565) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_565( CHAN_TO_UBYTE(src[RCOMP]),

-                                               CHAN_TO_UBYTE(src[GCOMP]),

-                                               CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 3;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_565_REV( CHAN_TO_UBYTE(src[RCOMP]),

-                                                   CHAN_TO_UBYTE(src[GCOMP]),

-                                                   CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 3;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a texture in MESA_FORMAT_RGBA8888 or MESA_FORMAT_RGBA8888_REV.

- */

-static GLboolean

-_mesa_texstore_rgba8888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA8888 ||

-          dstFormat == MESA_FORMAT_RGBA8888_REV);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_RGBA8888 &&

-       baseInternalFormat == GL_RGBA &&

-      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8) ||

-       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && !littleEndian) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && littleEndian))) {

-       /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_RGBA8888_REV &&

-       baseInternalFormat == GL_RGBA &&

-      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||

-       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && littleEndian) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && !littleEndian))) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-	    (srcType == GL_UNSIGNED_BYTE ||

-	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if ((littleEndian && dstFormat == MESA_FORMAT_RGBA8888) ||

-	  (!littleEndian && dstFormat == MESA_FORMAT_RGBA8888_REV)) {

-	 dstmap[3] = 0;

-	 dstmap[2] = 1;

-	 dstmap[1] = 2;

-	 dstmap[0] = 3;

-      }

-      else {

-	 dstmap[3] = 3;

-	 dstmap[2] = 2;

-	 dstmap[1] = 1;

-	 dstmap[0] = 0;

-      }

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 4,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint *) dstRow;

-            if (dstFormat == MESA_FORMAT_RGBA8888) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]),

-                                                CHAN_TO_UBYTE(src[ACOMP]) );

-                  src += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[RCOMP]),

-                                                    CHAN_TO_UBYTE(src[GCOMP]),

-                                                    CHAN_TO_UBYTE(src[BCOMP]),

-                                                    CHAN_TO_UBYTE(src[ACOMP]) );

-                  src += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_argb8888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = GL_RGBA;

-

-   ASSERT(dstFormat == MESA_FORMAT_ARGB8888 ||

-          dstFormat == MESA_FORMAT_ARGB8888_REV ||

-          dstFormat == MESA_FORMAT_XRGB8888 ||

-          dstFormat == MESA_FORMAT_XRGB8888_REV );

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       (dstFormat == MESA_FORMAT_ARGB8888 ||

-        dstFormat == MESA_FORMAT_XRGB8888) &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_BGRA &&

-       ((srcType == GL_UNSIGNED_BYTE && littleEndian) ||

-        srcType == GL_UNSIGNED_INT_8_8_8_8_REV)) {

-      /* simple memcpy path (little endian) */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       (dstFormat == MESA_FORMAT_ARGB8888_REV ||

-        dstFormat == MESA_FORMAT_XRGB8888_REV) &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_BGRA &&

-       ((srcType == GL_UNSIGNED_BYTE && !littleEndian) ||

-        srcType == GL_UNSIGNED_INT_8_8_8_8)) {

-      /* simple memcpy path (big endian) */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-	    (dstFormat == MESA_FORMAT_ARGB8888 ||

-             dstFormat == MESA_FORMAT_XRGB8888) &&

-            srcFormat == GL_RGB &&

-	    (baseInternalFormat == GL_RGBA ||

-	     baseInternalFormat == GL_RGB) &&

-            srcType == GL_UNSIGNED_BYTE) {

-      int img, row, col;

-      for (img = 0; img < srcDepth; img++) {

-         const GLint srcRowStride =

-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *d4 = (GLuint *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               d4[col] = PACK_COLOR_8888(0xff,

-                                         srcRow[col * 3 + RCOMP],

-                                         srcRow[col * 3 + GCOMP],

-                                         srcRow[col * 3 + BCOMP]);

-            }

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-      }

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-	    dstFormat == MESA_FORMAT_ARGB8888 &&

-            srcFormat == GL_RGBA &&

-	    baseInternalFormat == GL_RGBA &&

-            srcType == GL_UNSIGNED_BYTE) {

-      /* same as above case, but src data has alpha too */

-      GLint img, row, col;

-      /* For some reason, streaming copies to write-combined regions

-       * are extremely sensitive to the characteristics of how the

-       * source data is retrieved.  By reordering the source reads to

-       * be in-order, the speed of this operation increases by half.

-       * Strangely the same isn't required for the RGB path, above.

-       */

-      for (img = 0; img < srcDepth; img++) {

-         const GLint srcRowStride =

-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *d4 = (GLuint *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               d4[col] = PACK_COLOR_8888(srcRow[col * 4 + ACOMP],

-                                         srcRow[col * 4 + RCOMP],

-                                         srcRow[col * 4 + GCOMP],

-                                         srcRow[col * 4 + BCOMP]);

-            }

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-      }

-   }

-   else if (!ctx->_ImageTransferState &&

-	    (srcType == GL_UNSIGNED_BYTE ||

-	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||

-	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&

-	    can_swizzle(baseInternalFormat) &&	   

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if ((littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||

-          (littleEndian && dstFormat == MESA_FORMAT_XRGB8888) ||

-	  (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||

-	  (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV)) {

-	 dstmap[3] = 3;		/* alpha */

-	 dstmap[2] = 0;		/* red */

-	 dstmap[1] = 1;		/* green */

-	 dstmap[0] = 2;		/* blue */

-      }

-      else {

-	 assert((littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||

-		(!littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||

-		(littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV) ||

-		(!littleEndian && dstFormat == MESA_FORMAT_XRGB8888));

-	 dstmap[3] = 2;

-	 dstmap[2] = 1;

-	 dstmap[1] = 0;

-	 dstmap[0] = 3;

-      }

- 

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 4,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride,

-                                dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint *) dstRow;

-            if (dstFormat == MESA_FORMAT_ARGB8888) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[ACOMP]),

-                                                CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            else if (dstFormat == MESA_FORMAT_XRGB8888) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888( 0xff,

-                                                CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[ACOMP]),

-                                                    CHAN_TO_UBYTE(src[RCOMP]),

-                                                    CHAN_TO_UBYTE(src[GCOMP]),

-                                                    CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_rgb888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGB888);

-   ASSERT(texelBytes == 3);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGB &&

-       srcFormat == GL_BGR &&

-       srcType == GL_UNSIGNED_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-            srcFormat == GL_RGBA &&

-            srcType == GL_UNSIGNED_BYTE) {

-      /* extract RGB from RGBA */

-      GLint img, row, col;

-      for (img = 0; img < srcDepth; img++) {

-         const GLint srcRowStride =

-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col * 3 + 0] = srcRow[col * 4 + BCOMP];

-               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];

-               dstRow[col * 3 + 2] = srcRow[col * 4 + RCOMP];

-            }

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-      }

-   }

-   else if (!ctx->_ImageTransferState &&

-	    srcType == GL_UNSIGNED_BYTE &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      dstmap[0] = 2;

-      dstmap[1] = 1;

-      dstmap[2] = 0;

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 3,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = (const GLchan *) tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-#if 0

-            if (littleEndian) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);

-                  dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

-                  dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);

-                  srcUB += 3;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstRow[col * 3 + 0] = srcUB[BCOMP];

-                  dstRow[col * 3 + 1] = srcUB[GCOMP];

-                  dstRow[col * 3 + 2] = srcUB[RCOMP];

-                  srcUB += 3;

-               }

-            }

-#else

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[BCOMP]);

-               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

-               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[RCOMP]);

-               src += 3;

-            }

-#endif

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_bgr888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_BGR888);

-   ASSERT(texelBytes == 3);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGB &&

-       srcFormat == GL_RGB &&

-       srcType == GL_UNSIGNED_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-            !srcPacking->SwapBytes &&

-            srcFormat == GL_RGBA &&

-            srcType == GL_UNSIGNED_BYTE) {

-      /* extract BGR from RGBA */

-      int img, row, col;

-      for (img = 0; img < srcDepth; img++) {

-         const GLint srcRowStride =

-            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);

-         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,

-                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col * 3 + 0] = srcRow[col * 4 + RCOMP];

-               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];

-               dstRow[col * 3 + 2] = srcRow[col * 4 + BCOMP];

-            }

-            dstRow += dstRowStride;

-            srcRow += srcRowStride;

-         }

-      }

-   }

-   else if (!ctx->_ImageTransferState &&

-	    srcType == GL_UNSIGNED_BYTE &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      dstmap[0] = 0;

-      dstmap[1] = 1;

-      dstmap[2] = 2;

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 3,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }   

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = (const GLchan *) tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);

-               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);

-               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);

-               src += 3;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_argb4444(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_ARGB4444 ||

-          dstFormat == MESA_FORMAT_ARGB4444_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_ARGB4444 &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_BGRA &&

-       srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            if (dstFormat == MESA_FORMAT_ARGB4444) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_4444( CHAN_TO_UBYTE(src[ACOMP]),

-                                                CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_4444_REV( CHAN_TO_UBYTE(src[ACOMP]),

-                                                    CHAN_TO_UBYTE(src[RCOMP]),

-                                                    CHAN_TO_UBYTE(src[GCOMP]),

-                                                    CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-static GLboolean

-_mesa_texstore_rgba5551(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA5551);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_RGBA5551 &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_RGBA &&

-       srcType == GL_UNSIGNED_SHORT_5_5_5_1) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src =tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-	    for (col = 0; col < srcWidth; col++) {

-	       dstUS[col] = PACK_COLOR_5551( CHAN_TO_UBYTE(src[RCOMP]),

-					     CHAN_TO_UBYTE(src[GCOMP]),

-					     CHAN_TO_UBYTE(src[BCOMP]),

-					     CHAN_TO_UBYTE(src[ACOMP]) );

-	      src += 4;

-	    }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-static GLboolean

-_mesa_texstore_argb1555(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_ARGB1555 ||

-          dstFormat == MESA_FORMAT_ARGB1555_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_ARGB1555 &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_BGRA &&

-       srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src =tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            if (dstFormat == MESA_FORMAT_ARGB1555) {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_1555( CHAN_TO_UBYTE(src[ACOMP]),

-                                                CHAN_TO_UBYTE(src[RCOMP]),

-                                                CHAN_TO_UBYTE(src[GCOMP]),

-                                                CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dstUS[col] = PACK_COLOR_1555_REV( CHAN_TO_UBYTE(src[ACOMP]),

-                                                    CHAN_TO_UBYTE(src[RCOMP]),

-                                                    CHAN_TO_UBYTE(src[GCOMP]),

-                                                    CHAN_TO_UBYTE(src[BCOMP]) );

-                  src += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_argb2101010(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_ARGB2101010);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_ARGB2101010 &&

-       srcFormat == GL_BGRA &&

-       srcType == GL_UNSIGNED_INT_2_10_10_10_REV &&

-       baseInternalFormat == GL_RGBA) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         if (baseInternalFormat == GL_RGBA) {

-            for (row = 0; row < srcHeight; row++) {

-               GLuint *dstUI = (GLuint *) dstRow;

-               for (col = 0; col < srcWidth; col++) {

-                  GLushort a,r,g,b;

-

-                  UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);

-                  dstUI[col] = PACK_COLOR_2101010_US(a, r, g, b);

-                  src += 4;

-               }

-               dstRow += dstRowStride;

-            }

-         } else if (baseInternalFormat == GL_RGB) {

-            for (row = 0; row < srcHeight; row++) {

-               GLuint *dstUI = (GLuint *) dstRow;

-               for (col = 0; col < srcWidth; col++) {

-                  GLushort r,g,b;

-

-                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);

-                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);

-                  dstUI[col] = PACK_COLOR_2101010_US(0xffff, r, g, b);

-                  src += 4;

-               }

-               dstRow += dstRowStride;

-            }

-         } else {

-            ASSERT(0);

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Do texstore for 2-channel, 4-bit/channel, unsigned normalized formats.

- */

-static GLboolean

-_mesa_texstore_unorm44(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_AL44);

-   ASSERT(texelBytes == 1);

-

-   {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLubyte *dstUS = (GLubyte *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               /* src[0] is luminance, src[1] is alpha */

-               dstUS[col] = PACK_COLOR_44( CHAN_TO_UBYTE(src[1]),

-                                           CHAN_TO_UBYTE(src[0]) );

-               src += 2;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Do texstore for 2-channel, 8-bit/channel, unsigned normalized formats.

- */

-static GLboolean

-_mesa_texstore_unorm88(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_AL88 ||

-          dstFormat == MESA_FORMAT_AL88_REV ||

-          dstFormat == MESA_FORMAT_RG88 ||

-          dstFormat == MESA_FORMAT_RG88_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       ((dstFormat == MESA_FORMAT_AL88 &&

-         baseInternalFormat == GL_LUMINANCE_ALPHA &&

-         srcFormat == GL_LUMINANCE_ALPHA) ||

-        (dstFormat == MESA_FORMAT_RG88 &&

-         baseInternalFormat == srcFormat)) &&

-       srcType == GL_UNSIGNED_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-	    littleEndian &&

-	    srcType == GL_UNSIGNED_BYTE &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_AL88_REV) {

-	 if ((littleEndian && dstFormat == MESA_FORMAT_AL88) ||

-	     (!littleEndian && dstFormat == MESA_FORMAT_AL88_REV)) {

-	    dstmap[0] = 0;

-	    dstmap[1] = 3;

-	 }

-	 else {

-	    dstmap[0] = 3;

-	    dstmap[1] = 0;

-	 }

-      }

-      else {

-	 if ((littleEndian && dstFormat == MESA_FORMAT_RG88) ||

-	     (!littleEndian && dstFormat == MESA_FORMAT_RG88_REV)) {

-	    dstmap[0] = 0;

-	    dstmap[1] = 1;

-	 }

-	 else {

-	    dstmap[0] = 1;

-	    dstmap[1] = 0;

-	 }

-      }

-      dstmap[2] = ZERO;		/* ? */

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 2,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }   

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            if (dstFormat == MESA_FORMAT_AL88 ||

-		dstFormat == MESA_FORMAT_RG88) {

-               for (col = 0; col < srcWidth; col++) {

-                  /* src[0] is luminance, src[1] is alpha */

-                 dstUS[col] = PACK_COLOR_88( CHAN_TO_UBYTE(src[1]),

-                                             CHAN_TO_UBYTE(src[0]) );

-                 src += 2;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  /* src[0] is luminance, src[1] is alpha */

-                 dstUS[col] = PACK_COLOR_88_REV( CHAN_TO_UBYTE(src[1]),

-                                                 CHAN_TO_UBYTE(src[0]) );

-                 src += 2;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Do texstore for 2-channel, 16-bit/channel, unsigned normalized formats.

- */

-static GLboolean

-_mesa_texstore_unorm1616(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_AL1616 ||

-          dstFormat == MESA_FORMAT_AL1616_REV ||

-	  dstFormat == MESA_FORMAT_RG1616 ||

-          dstFormat == MESA_FORMAT_RG1616_REV);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       ((dstFormat == MESA_FORMAT_AL1616 &&

-         baseInternalFormat == GL_LUMINANCE_ALPHA &&

-         srcFormat == GL_LUMINANCE_ALPHA) ||

-        (dstFormat == MESA_FORMAT_RG1616 &&

-         baseInternalFormat == srcFormat)) &&

-       srcType == GL_UNSIGNED_SHORT &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint *) dstRow;

-            if (dstFormat == MESA_FORMAT_AL1616 ||

-		dstFormat == MESA_FORMAT_RG1616) {

-               for (col = 0; col < srcWidth; col++) {

-		  GLushort l, a;

-

-		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);

-		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);

-		  dstUI[col] = PACK_COLOR_1616(a, l);

-		  src += 2;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-		  GLushort l, a;

-

-		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);

-		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);

-		  dstUI[col] = PACK_COLOR_1616_REV(a, l);

-		  src += 2;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* Texstore for R16, A16, L16, I16. */

-static GLboolean

-_mesa_texstore_unorm16(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_R16 ||

-          dstFormat == MESA_FORMAT_A16 ||

-          dstFormat == MESA_FORMAT_L16 ||

-          dstFormat == MESA_FORMAT_I16);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_SHORT &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-	    for (col = 0; col < srcWidth; col++) {

-	       GLushort r;

-

-	       UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);

-	       dstUS[col] = r;

-	       src += 1;

-	    }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_rgba_16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_16);

-   ASSERT(texelBytes == 8);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGBA &&

-       srcFormat == GL_RGBA &&

-       srcType == GL_UNSIGNED_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstUS = (GLushort *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               GLushort r, g, b, a;

-

-               UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);

-               UNCLAMPED_FLOAT_TO_USHORT(g, src[1]);

-               UNCLAMPED_FLOAT_TO_USHORT(b, src[2]);

-               UNCLAMPED_FLOAT_TO_USHORT(a, src[3]);

-               dstUS[col*4+0] = r;

-               dstUS[col*4+1] = g;

-               dstUS[col*4+2] = b;

-               dstUS[col*4+3] = a;

-               src += 4;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGB_16 ||

-          dstFormat == MESA_FORMAT_SIGNED_RGBA_16);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGBA &&

-       dstFormat == MESA_FORMAT_SIGNED_RGBA_16 &&

-       srcFormat == GL_RGBA &&

-       srcType == GL_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      const GLuint comps = _mesa_get_format_bytes(dstFormat) / 2;

-      GLint img, row, col;

-

-      if (!tempImage)

-         return GL_FALSE;

-

-      /* Note: tempImage is always float[4] / RGBA.  We convert to 1, 2,

-       * 3 or 4 components/pixel here.

-       */

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLshort *dstRowS = (GLshort *) dstRow;

-            if (dstFormat == MESA_FORMAT_SIGNED_RGBA_16) {

-               for (col = 0; col < srcWidth; col++) {

-                  GLuint c;

-                  for (c = 0; c < comps; c++) {

-                     GLshort p;

-                     UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 4 + c]);

-                     dstRowS[col * comps + c] = p;

-                  }

-               }

-               dstRow += dstRowStride;

-               src += 4 * srcWidth;

-            } else {

-               for (col = 0; col < srcWidth; col++) {

-                  GLuint c;

-                  for (c = 0; c < comps; c++) {

-                     GLshort p;

-                     UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 3 + c]);

-                     dstRowS[col * comps + c] = p;

-                  }

-               }

-               dstRow += dstRowStride;

-               src += 3 * srcWidth;

-            }

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-static GLboolean

-_mesa_texstore_rgb332(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGB332);

-   ASSERT(texelBytes == 1);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == GL_RGB &&

-       srcFormat == GL_RGB && srcType == GL_UNSIGNED_BYTE_3_3_2) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col] = PACK_COLOR_332( CHAN_TO_UBYTE(src[RCOMP]),

-                                             CHAN_TO_UBYTE(src[GCOMP]),

-                                             CHAN_TO_UBYTE(src[BCOMP]) );

-               src += 3;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Texstore for _mesa_texformat_a8, _mesa_texformat_l8, _mesa_texformat_i8.

- */

-static GLboolean

-_mesa_texstore_unorm8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_A8 ||

-          dstFormat == MESA_FORMAT_L8 ||

-          dstFormat == MESA_FORMAT_I8 ||

-          dstFormat == MESA_FORMAT_R8);

-   ASSERT(texelBytes == 1);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-	    srcType == GL_UNSIGNED_BYTE &&

-	    can_swizzle(baseInternalFormat) &&

-	    can_swizzle(srcFormat)) {

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if (dstFormat == MESA_FORMAT_A8) {

-	 dstmap[0] = 3;

-      }

-      else {

-	 dstmap[0] = 0;

-      }

-      dstmap[1] = ZERO;		/* ? */

-      dstmap[2] = ZERO;		/* ? */

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				srcFormat,

-				srcType,

-				baseInternalFormat,

-				dstmap, 1,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }   

-   else {

-      /* general path */

-      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking);

-      const GLchan *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col] = CHAN_TO_UBYTE(src[col]);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-static GLboolean

-_mesa_texstore_ci8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-

-   (void) dims; (void) baseInternalFormat;

-   ASSERT(dstFormat == MESA_FORMAT_CI8);

-   ASSERT(texelBytes == 1);

-   ASSERT(baseInternalFormat == GL_COLOR_INDEX);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       srcFormat == GL_COLOR_INDEX &&

-       srcType == GL_UNSIGNED_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            const GLvoid *src = _mesa_image_address(dims, srcPacking,

-                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);

-            _mesa_unpack_index_span(ctx, srcWidth, GL_UNSIGNED_BYTE, dstRow,

-                                    srcType, src, srcPacking,

-                                    ctx->_ImageTransferState);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.

- */

-static GLboolean

-_mesa_texstore_ycbcr(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-

-   (void) ctx; (void) dims; (void) baseInternalFormat;

-

-   ASSERT((dstFormat == MESA_FORMAT_YCBCR) ||

-          (dstFormat == MESA_FORMAT_YCBCR_REV));

-   ASSERT(texelBytes == 2);

-   ASSERT(ctx->Extensions.MESA_ycbcr_texture);

-   ASSERT(srcFormat == GL_YCBCR_MESA);

-   ASSERT((srcType == GL_UNSIGNED_SHORT_8_8_MESA) ||

-          (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));

-   ASSERT(baseInternalFormat == GL_YCBCR_MESA);

-

-   /* always just memcpy since no pixel transfer ops apply */

-   memcpy_texture(ctx, dims,

-                  dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                  dstRowStride,

-                  dstImageOffsets,

-                  srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                  srcAddr, srcPacking);

-

-   /* Check if we need byte swapping */

-   /* XXX the logic here _might_ be wrong */

-   if (srcPacking->SwapBytes ^

-       (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^

-       (dstFormat == MESA_FORMAT_YCBCR_REV) ^

-       !littleEndian) {

-      GLint img, row;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            _mesa_swap2((GLushort *) dstRow, srcWidth);

-            dstRow += dstRowStride;

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-static GLboolean

-_mesa_texstore_dudv8(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_DUDV8);

-   ASSERT(texelBytes == 2);

-   ASSERT(ctx->Extensions.ATI_envmap_bumpmap);

-   ASSERT((srcFormat == GL_DU8DV8_ATI) ||

-	  (srcFormat == GL_DUDV_ATI));

-   ASSERT(baseInternalFormat == GL_DUDV_ATI);

-

-   if (!srcPacking->SwapBytes && srcType == GL_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (srcType == GL_BYTE) {

-      GLubyte dstmap[4];

-

-      /* dstmap - how to swizzle from RGBA to dst format:

-       */

-      if (littleEndian) {

-	 dstmap[0] = 0;

-	 dstmap[1] = 3;

-      }

-      else {

-	 dstmap[0] = 3;

-	 dstmap[1] = 0;

-      }

-      dstmap[2] = ZERO;		/* ? */

-      dstmap[3] = ONE;		/* ? */

-      

-      _mesa_swizzle_ubyte_image(ctx, dims,

-				GL_LUMINANCE_ALPHA, /* hack */

-				GL_UNSIGNED_BYTE, /* hack */

-				GL_LUMINANCE_ALPHA, /* hack */

-				dstmap, 2,

-				dstAddr, dstXoffset, dstYoffset, dstZoffset,

-				dstRowStride, dstImageOffsets,

-				srcWidth, srcHeight, srcDepth, srcAddr,

-				srcPacking);      

-   }   

-   else {

-      /* general path - note this is defined for 2d textures only */

-      const GLint components = _mesa_components_in_format(baseInternalFormat);

-      const GLint srcStride = _mesa_image_row_stride(srcPacking, srcWidth,

-                                                     srcFormat, srcType);

-      GLbyte *tempImage, *dst, *src;

-      GLint row;

-

-      tempImage = (GLbyte *) malloc(srcWidth * srcHeight * srcDepth

-                                          * components * sizeof(GLbyte));

-      if (!tempImage)

-         return GL_FALSE;

-

-      src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr,

-                                           srcWidth, srcHeight,

-                                           srcFormat, srcType,

-                                           0, 0, 0);

-

-      dst = tempImage;

-      for (row = 0; row < srcHeight; row++) {

-         _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat,

-                                     dst, srcFormat, srcType, src,

-                                     srcPacking, 0);

-         dst += srcWidth * components;

-         src += srcStride;

-      }

- 

-      src = tempImage;

-      dst = (GLbyte *) dstAddr

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-      for (row = 0; row < srcHeight; row++) {

-         memcpy(dst, src, srcWidth * texelBytes);

-         dst += dstRowStride;

-         src += srcWidth * texelBytes;

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a texture in a signed normalized 8-bit format.

- */

-static GLboolean

-_mesa_texstore_snorm8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_A8 ||

-          dstFormat == MESA_FORMAT_SIGNED_L8 ||

-          dstFormat == MESA_FORMAT_SIGNED_I8 ||

-          dstFormat == MESA_FORMAT_SIGNED_R8);

-   ASSERT(texelBytes == 1);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLbyte *dstRow = (GLbyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            for (col = 0; col < srcWidth; col++) {

-               dstRow[col] = FLOAT_TO_BYTE_TEX(src[col]);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a texture in a signed normalized two-channel 16-bit format.

- */

-static GLboolean

-_mesa_texstore_snorm88(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL88 ||

-          dstFormat == MESA_FORMAT_SIGNED_RG88_REV);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_BYTE &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLbyte *dstRow = (GLbyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLbyte *dst = dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               dst[0] = FLOAT_TO_BYTE_TEX(src[0]);

-               dst[1] = FLOAT_TO_BYTE_TEX(src[1]);

-               src += 2;

-               dst += 2;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-/* Texstore for signed R16, A16, L16, I16. */

-static GLboolean

-_mesa_texstore_snorm16(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R16 ||

-          dstFormat == MESA_FORMAT_SIGNED_A16 ||

-          dstFormat == MESA_FORMAT_SIGNED_L16 ||

-          dstFormat == MESA_FORMAT_SIGNED_I16);

-   ASSERT(texelBytes == 2);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_SHORT &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLshort *dstUS = (GLshort *) dstRow;

-	    for (col = 0; col < srcWidth; col++) {

-	       GLushort r;

-

-	       UNCLAMPED_FLOAT_TO_SHORT(r, src[0]);

-	       dstUS[col] = r;

-	       src += 1;

-	    }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-/**

- * Do texstore for 2-channel, 16-bit/channel, signed normalized formats.

- */

-static GLboolean

-_mesa_texstore_snorm1616(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL1616 ||

-          dstFormat == MESA_FORMAT_SIGNED_GR1616);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_SHORT &&

-       littleEndian) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLshort *dst = (GLshort *) dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               GLushort l, a;

-

-               UNCLAMPED_FLOAT_TO_SHORT(l, src[0]);

-               UNCLAMPED_FLOAT_TO_SHORT(a, src[1]);

-               dst[0] = l;

-               dst[1] = a;

-               src += 2;

-               dst += 2;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-/**

- * Store a texture in MESA_FORMAT_SIGNED_RGBX8888.

- */

-static GLboolean

-_mesa_texstore_signed_rgbx8888(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBX8888);

-   ASSERT(texelBytes == 4);

-

-   {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLbyte *dstRow = (GLbyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLbyte *dst = dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               dst[3] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);

-               dst[2] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);

-               dst[1] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);

-               dst[0] = 127;

-               srcRow += 3;

-               dst += 4;

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-/**

- * Store a texture in MESA_FORMAT_SIGNED_RGBA8888 or

- * MESA_FORMAT_SIGNED_RGBA8888_REV

- */

-static GLboolean

-_mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)

-{

-   const GLboolean littleEndian = _mesa_little_endian();

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBA8888 ||

-          dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV);

-   ASSERT(texelBytes == 4);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_SIGNED_RGBA8888 &&

-       baseInternalFormat == GL_RGBA &&

-      ((srcFormat == GL_RGBA && srcType == GL_BYTE && !littleEndian) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && littleEndian))) {

-       /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV &&

-       baseInternalFormat == GL_RGBA &&

-      ((srcFormat == GL_RGBA && srcType == GL_BYTE && littleEndian) ||

-       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && !littleEndian))) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLbyte *dstRow = (GLbyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLbyte *dst = dstRow;

-            if (dstFormat == MESA_FORMAT_SIGNED_RGBA8888) {

-               for (col = 0; col < srcWidth; col++) {

-                  dst[3] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);

-                  dst[2] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);

-                  dst[1] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);

-                  dst[0] = FLOAT_TO_BYTE_TEX(srcRow[ACOMP]);

-                  srcRow += 4;

-                  dst += 4;

-               }

-            }

-            else {

-               for (col = 0; col < srcWidth; col++) {

-                  dst[0] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);

-                  dst[1] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);

-                  dst[2] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);

-                  dst[3] = FLOAT_TO_BYTE_TEX(srcRow[ACOMP]);

-                  srcRow += 4;

-                  dst += 4;

-               }

-            }

-            dstRow += dstRowStride;

-         }

-      }

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a combined depth/stencil texture image.

- */

-static GLboolean

-_mesa_texstore_z24_s8(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffff;

-   const GLint srcRowStride

-      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

-      / sizeof(GLuint);

-   GLint img, row;

-

-   ASSERT(dstFormat == MESA_FORMAT_Z24_S8);

-   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT || srcFormat == GL_DEPTH_COMPONENT);

-   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);

-

-   if (srcFormat != GL_DEPTH_COMPONENT && ctx->Pixel.DepthScale == 1.0f &&

-       ctx->Pixel.DepthBias == 0.0f &&

-       !srcPacking->SwapBytes) {

-      /* simple path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else if (srcFormat == GL_DEPTH_COMPONENT) {

-      /* In case we only upload depth we need to preserve the stencil */

-      for (img = 0; img < srcDepth; img++) {

-	 GLuint *dstRow = (GLuint *) dstAddr

-            + dstImageOffsets[dstZoffset + img]

-            + dstYoffset * dstRowStride / sizeof(GLuint)

-            + dstXoffset;

-         const GLuint *src

-            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

-                  srcWidth, srcHeight,

-                  srcFormat, srcType,

-                  img, 0, 0);

-         for (row = 0; row < srcHeight; row++) {

-            GLuint depth[MAX_WIDTH];

-	    GLubyte stencil[MAX_WIDTH];

-            GLint i;

-	    GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;

-

-	    if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */

-	       keepstencil = GL_TRUE;

-	    }

-            else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */

-	       keepdepth = GL_TRUE;

-	    }

-

-	    if (keepdepth == GL_FALSE)

-	       /* the 24 depth bits will be in the low position: */

-	       _mesa_unpack_depth_span(ctx, srcWidth,

-				       GL_UNSIGNED_INT, /* dst type */

-				       keepstencil ? depth : dstRow, /* dst addr */

-				       depthScale,

-				       srcType, src, srcPacking);

-

-	    if (keepstencil == GL_FALSE)

-	       /* get the 8-bit stencil values */

-	       _mesa_unpack_stencil_span(ctx, srcWidth,

-					 GL_UNSIGNED_BYTE, /* dst type */

-					 stencil, /* dst addr */

-					 srcType, src, srcPacking,

-					 ctx->_ImageTransferState);

-

-	    for (i = 0; i < srcWidth; i++) {

-	       if (keepstencil)

-		  dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);

-	       else

-		  dstRow[i] = (dstRow[i] & 0xFFFFFF00) | (stencil[i] & 0xFF);

-	    }

-

-            src += srcRowStride;

-            dstRow += dstRowStride / sizeof(GLuint);

-         }

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store a combined depth/stencil texture image.

- */

-static GLboolean

-_mesa_texstore_s8_z24(TEXSTORE_PARAMS)

-{

-   const GLuint depthScale = 0xffffff;

-   const GLint srcRowStride

-      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

-      / sizeof(GLuint);

-   GLint img, row;

-

-   ASSERT(dstFormat == MESA_FORMAT_S8_Z24);

-   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||

-          srcFormat == GL_DEPTH_COMPONENT ||

-          srcFormat == GL_STENCIL_INDEX);

-   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT ||

-          srcType == GL_UNSIGNED_INT_24_8_EXT);

-

-   for (img = 0; img < srcDepth; img++) {

-      GLuint *dstRow = (GLuint *) dstAddr

-	 + dstImageOffsets[dstZoffset + img]

-	 + dstYoffset * dstRowStride / sizeof(GLuint)

-	 + dstXoffset;

-      const GLuint *src

-	 = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

-						srcWidth, srcHeight,

-						srcFormat, srcType,

-						img, 0, 0);

-      for (row = 0; row < srcHeight; row++) {

-	 GLuint depth[MAX_WIDTH];

-	 GLubyte stencil[MAX_WIDTH];

-	 GLint i;

-	 GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;

-	 

-	 if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */

-	    keepstencil = GL_TRUE;

-	 }

-         else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */

-	    keepdepth = GL_TRUE;

-	 }

-

-	 if (keepdepth == GL_FALSE)

-	    /* the 24 depth bits will be in the low position: */

-	    _mesa_unpack_depth_span(ctx, srcWidth,

-				    GL_UNSIGNED_INT, /* dst type */

-				    keepstencil ? depth : dstRow, /* dst addr */

-				    depthScale,

-				    srcType, src, srcPacking);	 

-

-	 if (keepstencil == GL_FALSE)

-	    /* get the 8-bit stencil values */

-	    _mesa_unpack_stencil_span(ctx, srcWidth,

-				      GL_UNSIGNED_BYTE, /* dst type */

-				      stencil, /* dst addr */

-				      srcType, src, srcPacking,

-				      ctx->_ImageTransferState);

-

-	 /* merge stencil values into depth values */

-	 for (i = 0; i < srcWidth; i++) {

-	    if (keepstencil)

-	       dstRow[i] = depth[i] | (dstRow[i] & 0xFF000000);

-	    else

-	       dstRow[i] = (dstRow[i] & 0xFFFFFF) | (stencil[i] << 24);

-

-	 }

-	 src += srcRowStride;

-	 dstRow += dstRowStride / sizeof(GLuint);

-      }

-   }

-   return GL_TRUE;

-}

-

-

-/**

- * Store simple 8-bit/value stencil texture data.

- */

-static GLboolean

-_mesa_texstore_s8(TEXSTORE_PARAMS)

-{

-   ASSERT(dstFormat == MESA_FORMAT_S8);

-   ASSERT(srcFormat == GL_STENCIL_INDEX);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      const GLint srcRowStride

-	 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)

-	 / sizeof(GLuint);

-      GLint img, row;

-      

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img]

-            + dstYoffset * dstRowStride / sizeof(GLuint)

-            + dstXoffset;

-         const GLuint *src

-            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,

-                                                   srcWidth, srcHeight,

-                                                   srcFormat, srcType,

-                                                   img, 0, 0);

-         for (row = 0; row < srcHeight; row++) {

-            GLubyte stencil[MAX_WIDTH];

-            GLint i;

-

-            /* get the 8-bit stencil values */

-            _mesa_unpack_stencil_span(ctx, srcWidth,

-                                      GL_UNSIGNED_BYTE, /* dst type */

-                                      stencil, /* dst addr */

-                                      srcType, src, srcPacking,

-                                      ctx->_ImageTransferState);

-            /* merge stencil values into depth values */

-            for (i = 0; i < srcWidth; i++)

-               dstRow[i] = stencil[i];

-

-            src += srcRowStride;

-            dstRow += dstRowStride / sizeof(GLubyte);

-         }

-      }

-

-   }

-

-   return GL_TRUE;

-}

-

-

-/**

- * Store an image in any of the formats:

- *   _mesa_texformat_rgba_float32

- *   _mesa_texformat_rgb_float32

- *   _mesa_texformat_alpha_float32

- *   _mesa_texformat_luminance_float32

- *   _mesa_texformat_luminance_alpha_float32

- *   _mesa_texformat_intensity_float32

- */

-static GLboolean

-_mesa_texstore_rgba_float32(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT32 ||

-          dstFormat == MESA_FORMAT_RGB_FLOAT32 ||

-          dstFormat == MESA_FORMAT_ALPHA_FLOAT32 ||

-          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT32 ||

-          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 ||

-          dstFormat == MESA_FORMAT_INTENSITY_FLOAT32 ||

-          dstFormat == MESA_FORMAT_R_FLOAT32 ||

-          dstFormat == MESA_FORMAT_RG_FLOAT32);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY ||

-          baseInternalFormat == GL_RED ||

-          baseInternalFormat == GL_RG);

-   ASSERT(texelBytes == components * sizeof(GLfloat));

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       baseInternalFormat == baseFormat &&

-       srcType == GL_FLOAT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint bytesPerRow;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      bytesPerRow = srcWidth * components * sizeof(GLfloat);

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            memcpy(dstRow, srcRow, bytesPerRow);

-            dstRow += dstRowStride;

-            srcRow += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-/**

- * As above, but store 16-bit floats.

- */

-static GLboolean

-_mesa_texstore_rgba_float16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT16 ||

-          dstFormat == MESA_FORMAT_RGB_FLOAT16 ||

-          dstFormat == MESA_FORMAT_ALPHA_FLOAT16 ||

-          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT16 ||

-          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 ||

-          dstFormat == MESA_FORMAT_INTENSITY_FLOAT16 ||

-          dstFormat == MESA_FORMAT_R_FLOAT16 ||

-          dstFormat == MESA_FORMAT_RG_FLOAT16);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY ||

-          baseInternalFormat == GL_RED ||

-          baseInternalFormat == GL_RG);

-   ASSERT(texelBytes == components * sizeof(GLhalfARB));

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       baseInternalFormat == baseFormat &&

-       srcType == GL_HALF_FLOAT_ARB) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLhalfARB *dstTexel = (GLhalfARB *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = _mesa_float_to_half(src[i]);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, signed int8 */

-static GLboolean

-_mesa_texstore_rgba_int8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT8);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLbyte));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking, 0x0);

-      const GLfloat *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLbyte *dstTexel = (GLbyte *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLbyte) src[i];

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, signed int16 */

-static GLboolean

-_mesa_texstore_rgba_int16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT16);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLshort));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking, 0x0);

-      const GLfloat *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLshort *dstTexel = (GLshort *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLint) src[i];

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, signed int32 */

-static GLboolean

-_mesa_texstore_rgba_int32(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT32);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLint));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_INT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking, 0x0);

-      const GLfloat *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLint *dstTexel = (GLint *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLint) src[i];

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, unsigned int8 */

-static GLboolean

-_mesa_texstore_rgba_uint8(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT8);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLubyte));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_BYTE) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLuint *tempImage =

-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

-                              srcWidth, srcHeight, srcDepth,

-                              srcFormat, srcType, srcAddr, srcPacking);

-      const GLuint *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLubyte *dstTexel = (GLubyte *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLubyte) CLAMP(src[i], 0, 0xff);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, unsigned int16 */

-static GLboolean

-_mesa_texstore_rgba_uint16(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT16);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLushort));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_SHORT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLuint *tempImage =

-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

-                              srcWidth, srcHeight, srcDepth,

-                              srcFormat, srcType, srcAddr, srcPacking);

-      const GLuint *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLushort *dstTexel = (GLushort *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = (GLushort) CLAMP(src[i], 0, 0xffff);

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-/* non-normalized, unsigned int32 */

-static GLboolean

-_mesa_texstore_rgba_uint32(TEXSTORE_PARAMS)

-{

-   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-   const GLint components = _mesa_components_in_format(baseFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT32);

-   ASSERT(baseInternalFormat == GL_RGBA ||

-          baseInternalFormat == GL_RGB ||

-          baseInternalFormat == GL_ALPHA ||

-          baseInternalFormat == GL_LUMINANCE ||

-          baseInternalFormat == GL_LUMINANCE_ALPHA ||

-          baseInternalFormat == GL_INTENSITY);

-   ASSERT(texelBytes == components * sizeof(GLuint));

-

-   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply

-    * to integer formats.

-    */

-   if (!srcPacking->SwapBytes &&

-       baseInternalFormat == srcFormat &&

-       srcType == GL_UNSIGNED_INT) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLuint *tempImage =

-         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,

-                              srcWidth, srcHeight, srcDepth,

-                              srcFormat, srcType, srcAddr, srcPacking);

-      const GLuint *src = tempImage;

-      GLint img, row;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * texelBytes

-            + dstYoffset * dstRowStride

-            + dstXoffset * texelBytes;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstTexel = (GLuint *) dstRow;

-            GLint i;

-            for (i = 0; i < srcWidth * components; i++) {

-               dstTexel[i] = src[i];

-            }

-            dstRow += dstRowStride;

-            src += srcWidth * components;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-

-#if FEATURE_EXT_texture_sRGB

-static GLboolean

-_mesa_texstore_srgb8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SRGB8);

-

-   /* reuse normal rgb texstore code */

-   newDstFormat = MESA_FORMAT_RGB888;

-

-   k = _mesa_texstore_rgb888(ctx, dims, baseInternalFormat,

-                             newDstFormat, dstAddr,

-                             dstXoffset, dstYoffset, dstZoffset,

-                             dstRowStride, dstImageOffsets,

-                             srcWidth, srcHeight, srcDepth,

-                             srcFormat, srcType,

-                             srcAddr, srcPacking);

-   return k;

-}

-

-

-static GLboolean

-_mesa_texstore_srgba8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SRGBA8);

-

-   /* reuse normal rgba texstore code */

-   newDstFormat = MESA_FORMAT_RGBA8888;

-   k = _mesa_texstore_rgba8888(ctx, dims, baseInternalFormat,

-                               newDstFormat, dstAddr,

-                               dstXoffset, dstYoffset, dstZoffset,

-                               dstRowStride, dstImageOffsets,

-                               srcWidth, srcHeight, srcDepth,

-                               srcFormat, srcType,

-                               srcAddr, srcPacking);

-   return k;

-}

-

-

-static GLboolean

-_mesa_texstore_sargb8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SARGB8);

-

-   /* reuse normal rgba texstore code */

-   newDstFormat = MESA_FORMAT_ARGB8888;

-

-   k = _mesa_texstore_argb8888(ctx, dims, baseInternalFormat,

-                               newDstFormat, dstAddr,

-                               dstXoffset, dstYoffset, dstZoffset,

-                               dstRowStride, dstImageOffsets,

-                               srcWidth, srcHeight, srcDepth,

-                               srcFormat, srcType,

-                               srcAddr, srcPacking);

-   return k;

-}

-

-

-static GLboolean

-_mesa_texstore_sl8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SL8);

-

-   newDstFormat = MESA_FORMAT_L8;

-

-   /* _mesa_textore_a8 handles luminance8 too */

-   k = _mesa_texstore_unorm8(ctx, dims, baseInternalFormat,

-                         newDstFormat, dstAddr,

-                         dstXoffset, dstYoffset, dstZoffset,

-                         dstRowStride, dstImageOffsets,

-                         srcWidth, srcHeight, srcDepth,

-                         srcFormat, srcType,

-                         srcAddr, srcPacking);

-   return k;

-}

-

-

-static GLboolean

-_mesa_texstore_sla8(TEXSTORE_PARAMS)

-{

-   gl_format newDstFormat;

-   GLboolean k;

-

-   ASSERT(dstFormat == MESA_FORMAT_SLA8);

-

-   /* reuse normal luminance/alpha texstore code */

-   newDstFormat = MESA_FORMAT_AL88;

-

-   k = _mesa_texstore_unorm88(ctx, dims, baseInternalFormat,

-			      newDstFormat, dstAddr,

-			      dstXoffset, dstYoffset, dstZoffset,

-			      dstRowStride, dstImageOffsets,

-			      srcWidth, srcHeight, srcDepth,

-			      srcFormat, srcType,

-			      srcAddr, srcPacking);

-   return k;

-}

-

-#else

-

-/* these are used only in texstore_funcs[] below */

-#define _mesa_texstore_srgb8 NULL

-#define _mesa_texstore_srgba8 NULL

-#define _mesa_texstore_sargb8 NULL

-#define _mesa_texstore_sl8 NULL

-#define _mesa_texstore_sla8 NULL

-

-#endif /* FEATURE_EXT_texture_sRGB */

-

-static GLboolean

-_mesa_texstore_rgb9_e5(TEXSTORE_PARAMS)

-{

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_RGB9_E5_FLOAT);

-   ASSERT(baseInternalFormat == GL_RGB);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       srcFormat == GL_RGB &&

-       srcType == GL_UNSIGNED_INT_5_9_9_9_REV) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * 4

-            + dstYoffset * dstRowStride

-            + dstXoffset * 4;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint*)dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               dstUI[col] = float3_to_rgb9e5(&srcRow[col * 3]);

-            }

-            dstRow += dstRowStride;

-            srcRow += srcWidth * 3;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-static GLboolean

-_mesa_texstore_r11_g11_b10f(TEXSTORE_PARAMS)

-{

-   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);

-

-   ASSERT(dstFormat == MESA_FORMAT_R11_G11_B10_FLOAT);

-   ASSERT(baseInternalFormat == GL_RGB);

-

-   if (!ctx->_ImageTransferState &&

-       !srcPacking->SwapBytes &&

-       srcFormat == GL_RGB &&

-       srcType == GL_UNSIGNED_INT_10F_11F_11F_REV) {

-      /* simple memcpy path */

-      memcpy_texture(ctx, dims,

-                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                     dstRowStride,

-                     dstImageOffsets,

-                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,

-                     srcAddr, srcPacking);

-   }

-   else {

-      /* general path */

-      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,

-                                                 baseInternalFormat,

-                                                 baseFormat,

-                                                 srcWidth, srcHeight, srcDepth,

-                                                 srcFormat, srcType, srcAddr,

-                                                 srcPacking,

-                                                 ctx->_ImageTransferState);

-      const GLfloat *srcRow = tempImage;

-      GLint img, row, col;

-      if (!tempImage)

-         return GL_FALSE;

-      for (img = 0; img < srcDepth; img++) {

-         GLubyte *dstRow = (GLubyte *) dstAddr

-            + dstImageOffsets[dstZoffset + img] * 4

-            + dstYoffset * dstRowStride

-            + dstXoffset * 4;

-         for (row = 0; row < srcHeight; row++) {

-            GLuint *dstUI = (GLuint*)dstRow;

-            for (col = 0; col < srcWidth; col++) {

-               dstUI[col] = float3_to_r11g11b10f(&srcRow[col * 3]);

-            }

-            dstRow += dstRowStride;

-            srcRow += srcWidth * 3;

-         }

-      }

-

-      free((void *) tempImage);

-   }

-   return GL_TRUE;

-}

-

-

-

-/**

- * Table mapping MESA_FORMAT_* to _mesa_texstore_*()

- * XXX this is somewhat temporary.

- */

-static const struct {

-   gl_format Name;

-   StoreTexImageFunc Store;

-}

-texstore_funcs[MESA_FORMAT_COUNT] =

-{

-   { MESA_FORMAT_NONE, NULL },

-   { MESA_FORMAT_RGBA8888, _mesa_texstore_rgba8888 },

-   { MESA_FORMAT_RGBA8888_REV, _mesa_texstore_rgba8888 },

-   { MESA_FORMAT_ARGB8888, _mesa_texstore_argb8888 },

-   { MESA_FORMAT_ARGB8888_REV, _mesa_texstore_argb8888 },

-   { MESA_FORMAT_XRGB8888, _mesa_texstore_argb8888 },

-   { MESA_FORMAT_XRGB8888_REV, _mesa_texstore_argb8888 },

-   { MESA_FORMAT_RGB888, _mesa_texstore_rgb888 },

-   { MESA_FORMAT_BGR888, _mesa_texstore_bgr888 },

-   { MESA_FORMAT_RGB565, _mesa_texstore_rgb565 },

-   { MESA_FORMAT_RGB565_REV, _mesa_texstore_rgb565 },

-   { MESA_FORMAT_ARGB4444, _mesa_texstore_argb4444 },

-   { MESA_FORMAT_ARGB4444_REV, _mesa_texstore_argb4444 },

-   { MESA_FORMAT_RGBA5551, _mesa_texstore_rgba5551 },

-   { MESA_FORMAT_ARGB1555, _mesa_texstore_argb1555 },

-   { MESA_FORMAT_ARGB1555_REV, _mesa_texstore_argb1555 },

-   { MESA_FORMAT_AL44, _mesa_texstore_unorm44 },

-   { MESA_FORMAT_AL88, _mesa_texstore_unorm88 },

-   { MESA_FORMAT_AL88_REV, _mesa_texstore_unorm88 },

-   { MESA_FORMAT_AL1616, _mesa_texstore_unorm1616 },

-   { MESA_FORMAT_AL1616_REV, _mesa_texstore_unorm1616 },

-   { MESA_FORMAT_RGB332, _mesa_texstore_rgb332 },

-   { MESA_FORMAT_A8, _mesa_texstore_unorm8 },

-   { MESA_FORMAT_A16, _mesa_texstore_unorm16 },

-   { MESA_FORMAT_L8, _mesa_texstore_unorm8 },

-   { MESA_FORMAT_L16, _mesa_texstore_unorm16 },

-   { MESA_FORMAT_I8, _mesa_texstore_unorm8 },

-   { MESA_FORMAT_I16, _mesa_texstore_unorm16 },

-   { MESA_FORMAT_CI8, _mesa_texstore_ci8 },

-   { MESA_FORMAT_YCBCR, _mesa_texstore_ycbcr },

-   { MESA_FORMAT_YCBCR_REV, _mesa_texstore_ycbcr },

-   { MESA_FORMAT_R8, _mesa_texstore_unorm8 },

-   { MESA_FORMAT_RG88, _mesa_texstore_unorm88 },

-   { MESA_FORMAT_RG88_REV, _mesa_texstore_unorm88 },

-   { MESA_FORMAT_R16, _mesa_texstore_unorm16 },

-   { MESA_FORMAT_RG1616, _mesa_texstore_unorm1616 },

-   { MESA_FORMAT_RG1616_REV, _mesa_texstore_unorm1616 },

-   { MESA_FORMAT_ARGB2101010, _mesa_texstore_argb2101010 },

-   { MESA_FORMAT_Z24_S8, _mesa_texstore_z24_s8 },

-   { MESA_FORMAT_S8_Z24, _mesa_texstore_s8_z24 },

-   { MESA_FORMAT_Z16, _mesa_texstore_z16 },

-   { MESA_FORMAT_X8_Z24, _mesa_texstore_x8_z24 },

-   { MESA_FORMAT_Z24_X8, _mesa_texstore_z24_x8 },

-   { MESA_FORMAT_Z32, _mesa_texstore_z32 },

-   { MESA_FORMAT_S8, _mesa_texstore_s8 },

-   { MESA_FORMAT_SRGB8, _mesa_texstore_srgb8 },

-   { MESA_FORMAT_SRGBA8, _mesa_texstore_srgba8 },

-   { MESA_FORMAT_SARGB8, _mesa_texstore_sargb8 },

-   { MESA_FORMAT_SL8, _mesa_texstore_sl8 },

-   { MESA_FORMAT_SLA8, _mesa_texstore_sla8 },

-   { MESA_FORMAT_SRGB_DXT1, _mesa_texstore_rgb_dxt1 },

-   { MESA_FORMAT_SRGBA_DXT1, _mesa_texstore_rgba_dxt1 },

-   { MESA_FORMAT_SRGBA_DXT3, _mesa_texstore_rgba_dxt3 },

-   { MESA_FORMAT_SRGBA_DXT5, _mesa_texstore_rgba_dxt5 },

-   { MESA_FORMAT_RGB_FXT1, _mesa_texstore_rgb_fxt1 },

-   { MESA_FORMAT_RGBA_FXT1, _mesa_texstore_rgba_fxt1 },

-   { MESA_FORMAT_RGB_DXT1, _mesa_texstore_rgb_dxt1 },

-   { MESA_FORMAT_RGBA_DXT1, _mesa_texstore_rgba_dxt1 },

-   { MESA_FORMAT_RGBA_DXT3, _mesa_texstore_rgba_dxt3 },

-   { MESA_FORMAT_RGBA_DXT5, _mesa_texstore_rgba_dxt5 },

-   { MESA_FORMAT_RGBA_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_RGBA_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_RGB_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_RGB_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_LUMINANCE_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_LUMINANCE_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_INTENSITY_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_INTENSITY_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_R_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_R_FLOAT16, _mesa_texstore_rgba_float16 },

-   { MESA_FORMAT_RG_FLOAT32, _mesa_texstore_rgba_float32 },

-   { MESA_FORMAT_RG_FLOAT16, _mesa_texstore_rgba_float16 },

-

-   { MESA_FORMAT_RGBA_INT8, _mesa_texstore_rgba_int8 },

-   { MESA_FORMAT_RGBA_INT16, _mesa_texstore_rgba_int16 },

-   { MESA_FORMAT_RGBA_INT32, _mesa_texstore_rgba_int32 },

-   { MESA_FORMAT_RGBA_UINT8, _mesa_texstore_rgba_uint8 },

-   { MESA_FORMAT_RGBA_UINT16, _mesa_texstore_rgba_uint16 },

-   { MESA_FORMAT_RGBA_UINT32, _mesa_texstore_rgba_uint32 },

-

-   { MESA_FORMAT_DUDV8, _mesa_texstore_dudv8 },

-

-   { MESA_FORMAT_SIGNED_R8, _mesa_texstore_snorm8 },

-   { MESA_FORMAT_SIGNED_RG88_REV, _mesa_texstore_snorm88 },

-   { MESA_FORMAT_SIGNED_RGBX8888, _mesa_texstore_signed_rgbx8888 },

-

-   { MESA_FORMAT_SIGNED_RGBA8888, _mesa_texstore_signed_rgba8888 },

-   { MESA_FORMAT_SIGNED_RGBA8888_REV, _mesa_texstore_signed_rgba8888 },

-

-   { MESA_FORMAT_SIGNED_R16, _mesa_texstore_snorm16 },

-   { MESA_FORMAT_SIGNED_GR1616, _mesa_texstore_snorm1616 },

-   { MESA_FORMAT_SIGNED_RGB_16, _mesa_texstore_signed_rgba_16 },

-   { MESA_FORMAT_SIGNED_RGBA_16, _mesa_texstore_signed_rgba_16 },

-   { MESA_FORMAT_RGBA_16, _mesa_texstore_rgba_16 },

-

-   { MESA_FORMAT_RED_RGTC1, _mesa_texstore_red_rgtc1 },

-   { MESA_FORMAT_SIGNED_RED_RGTC1, _mesa_texstore_signed_red_rgtc1 },

-   { MESA_FORMAT_RG_RGTC2, _mesa_texstore_rg_rgtc2 },

-   { MESA_FORMAT_SIGNED_RG_RGTC2, _mesa_texstore_signed_rg_rgtc2 },

-

-   /* Re-use the R/RG texstore functions.

-    * The code is generic enough to handle LATC too. */

-   { MESA_FORMAT_L_LATC1, _mesa_texstore_red_rgtc1 },

-   { MESA_FORMAT_SIGNED_L_LATC1, _mesa_texstore_signed_red_rgtc1 },

-   { MESA_FORMAT_LA_LATC2, _mesa_texstore_rg_rgtc2 },

-   { MESA_FORMAT_SIGNED_LA_LATC2, _mesa_texstore_signed_rg_rgtc2 },

-

-   { MESA_FORMAT_SIGNED_A8, _mesa_texstore_snorm8 },

-   { MESA_FORMAT_SIGNED_L8, _mesa_texstore_snorm8 },

-   { MESA_FORMAT_SIGNED_AL88, _mesa_texstore_snorm88 },

-   { MESA_FORMAT_SIGNED_I8, _mesa_texstore_snorm8 },

-

-   { MESA_FORMAT_SIGNED_A16, _mesa_texstore_snorm16 },

-   { MESA_FORMAT_SIGNED_L16, _mesa_texstore_snorm16 },

-   { MESA_FORMAT_SIGNED_AL1616, _mesa_texstore_snorm1616 },

-   { MESA_FORMAT_SIGNED_I16, _mesa_texstore_snorm16 },

-

-   { MESA_FORMAT_RGB9_E5_FLOAT, _mesa_texstore_rgb9_e5 },

-   { MESA_FORMAT_R11_G11_B10_FLOAT, _mesa_texstore_r11_g11_b10f },

-};

-

-

-static GLboolean

-_mesa_texstore_null(TEXSTORE_PARAMS)

-{

-   (void) ctx; (void) dims;

-   (void) baseInternalFormat;

-   (void) dstFormat;

-   (void) dstAddr;

-   (void) dstXoffset; (void) dstYoffset; (void) dstZoffset;

-   (void) dstRowStride; (void) dstImageOffsets;

-   (void) srcWidth; (void) srcHeight; (void) srcDepth;

-   (void) srcFormat; (void) srcType;

-   (void) srcAddr;

-   (void) srcPacking;

-

-   /* should never happen */

-   _mesa_problem(NULL, "_mesa_texstore_null() is called");

-   return GL_FALSE;

-}

-

-

-/**

- * Return the StoreTexImageFunc pointer to store an image in the given format.

- */

-static StoreTexImageFunc

-_mesa_get_texstore_func(gl_format format)

-{

-#ifdef DEBUG

-   GLuint i;

-   for (i = 0; i < MESA_FORMAT_COUNT; i++) {

-      ASSERT(texstore_funcs[i].Name == i);

-   }

-#endif

-   ASSERT(texstore_funcs[format].Name == format);

-

-   if (texstore_funcs[format].Store)

-      return texstore_funcs[format].Store;

-   else

-      return _mesa_texstore_null;

-}

-

-

-/**

- * Store user data into texture memory.

- * Called via glTex[Sub]Image1/2/3D()

- */

-GLboolean

-_mesa_texstore(TEXSTORE_PARAMS)

-{

-   StoreTexImageFunc storeImage;

-   GLboolean success;

-

-   storeImage = _mesa_get_texstore_func(dstFormat);

-

-   success = storeImage(ctx, dims, baseInternalFormat,

-                        dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,

-                        dstRowStride, dstImageOffsets,

-                        srcWidth, srcHeight, srcDepth,

-                        srcFormat, srcType, srcAddr, srcPacking);

-   return success;

-}

-

-

-/** Return texture size in bytes */

-static GLuint

-texture_size(const struct gl_texture_image *texImage)

-{

-   GLuint sz = _mesa_format_image_size(texImage->TexFormat, texImage->Width,

-                                       texImage->Height, texImage->Depth);

-   return sz;

-}

-

-

-/** Return row stride in bytes */

-static GLuint

-texture_row_stride(const struct gl_texture_image *texImage)

-{

-   GLuint stride = _mesa_format_row_stride(texImage->TexFormat,

-                                           texImage->Width);

-   return stride;

-}

-

-

-

-/**

- * This is the software fallback for Driver.TexImage1D()

- * and Driver.CopyTexImage1D().

- * \sa _mesa_store_teximage2d()

- */

-void

-_mesa_store_teximage1d(struct gl_context *ctx, GLenum target, GLint level,

-                       GLint internalFormat,

-                       GLint width, GLint border,

-                       GLenum format, GLenum type, const GLvoid *pixels,

-                       const struct gl_pixelstore_attrib *packing,

-                       struct gl_texture_object *texObj,

-                       struct gl_texture_image *texImage)

-{

-   GLuint sizeInBytes;

-   (void) border;

-

-   /* allocate memory */

-   sizeInBytes = texture_size(texImage);

-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

-   if (!texImage->Data) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");

-      return;

-   }

-

-   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,

-                                        pixels, packing, "glTexImage1D");

-   if (!pixels) {

-      /* Note: we check for a NULL image pointer here, _after_ we allocated

-       * memory for the texture.  That's what the GL spec calls for.

-       */

-      return;

-   }

-   else {

-      const GLint dstRowStride = 0;

-      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         0, 0, 0,  /* dstX/Y/Zoffset */

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, 1, 1,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-/**

- * This is the software fallback for Driver.TexImage2D()

- * and Driver.CopyTexImage2D().

- *

- * This function is oriented toward storing images in main memory, rather

- * than VRAM.  Device driver's can easily plug in their own replacement.

- */

-void

-_mesa_store_teximage2d(struct gl_context *ctx, GLenum target, GLint level,

-                       GLint internalFormat,

-                       GLint width, GLint height, GLint border,

-                       GLenum format, GLenum type, const void *pixels,

-                       const struct gl_pixelstore_attrib *packing,

-                       struct gl_texture_object *texObj,

-                       struct gl_texture_image *texImage)

-{

-   GLuint sizeInBytes;

-   (void) border;

-

-   /* allocate memory */

-   sizeInBytes = texture_size(texImage);

-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

-   if (!texImage->Data) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");

-      return;

-   }

-

-   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,

-                                        pixels, packing, "glTexImage2D");

-   if (!pixels) {

-      /* Note: we check for a NULL image pointer here, _after_ we allocated

-       * memory for the texture.  That's what the GL spec calls for.

-       */

-      return;

-   }

-   else {

-      GLint dstRowStride = texture_row_stride(texImage);

-      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         0, 0, 0,  /* dstX/Y/Zoffset */

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, height, 1,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-

-/**

- * This is the software fallback for Driver.TexImage3D()

- * and Driver.CopyTexImage3D().

- * \sa _mesa_store_teximage2d()

- */

-void

-_mesa_store_teximage3d(struct gl_context *ctx, GLenum target, GLint level,

-                       GLint internalFormat,

-                       GLint width, GLint height, GLint depth, GLint border,

-                       GLenum format, GLenum type, const void *pixels,

-                       const struct gl_pixelstore_attrib *packing,

-                       struct gl_texture_object *texObj,

-                       struct gl_texture_image *texImage)

-{

-   GLuint sizeInBytes;

-   (void) border;

-

-   /* allocate memory */

-   sizeInBytes = texture_size(texImage);

-   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);

-   if (!texImage->Data) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");

-      return;

-   }

-

-   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,

-                                        type, pixels, packing, "glTexImage3D");

-   if (!pixels) {

-      /* Note: we check for a NULL image pointer here, _after_ we allocated

-       * memory for the texture.  That's what the GL spec calls for.

-       */

-      return;

-   }

-   else {

-      GLint dstRowStride = texture_row_stride(texImage);

-      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         0, 0, 0,  /* dstX/Y/Zoffset */

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, height, depth,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-

-

-/*

- * This is the software fallback for Driver.TexSubImage1D()

- * and Driver.CopyTexSubImage1D().

- */

-void

-_mesa_store_texsubimage1d(struct gl_context *ctx, GLenum target, GLint level,

-                          GLint xoffset, GLint width,

-                          GLenum format, GLenum type, const void *pixels,

-                          const struct gl_pixelstore_attrib *packing,

-                          struct gl_texture_object *texObj,

-                          struct gl_texture_image *texImage)

-{

-   /* get pointer to src pixels (may be in a pbo which we'll map here) */

-   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,

-                                        pixels, packing, "glTexSubImage1D");

-   if (!pixels)

-      return;

-

-   {

-      const GLint dstRowStride = 0;

-      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         xoffset, 0, 0,  /* offsets */

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, 1, 1,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage1D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-

-/**

- * This is the software fallback for Driver.TexSubImage2D()

- * and Driver.CopyTexSubImage2D().

- */

-void

-_mesa_store_texsubimage2d(struct gl_context *ctx, GLenum target, GLint level,

-                          GLint xoffset, GLint yoffset,

-                          GLint width, GLint height,

-                          GLenum format, GLenum type, const void *pixels,

-                          const struct gl_pixelstore_attrib *packing,

-                          struct gl_texture_object *texObj,

-                          struct gl_texture_image *texImage)

-{

-   /* get pointer to src pixels (may be in a pbo which we'll map here) */

-   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,

-                                        pixels, packing, "glTexSubImage2D");

-   if (!pixels)

-      return;

-

-   {

-      GLint dstRowStride = texture_row_stride(texImage);

-      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         xoffset, yoffset, 0,

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, height, 1,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage2D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-/*

- * This is the software fallback for Driver.TexSubImage3D().

- * and Driver.CopyTexSubImage3D().

- */

-void

-_mesa_store_texsubimage3d(struct gl_context *ctx, GLenum target, GLint level,

-                          GLint xoffset, GLint yoffset, GLint zoffset,

-                          GLint width, GLint height, GLint depth,

-                          GLenum format, GLenum type, const void *pixels,

-                          const struct gl_pixelstore_attrib *packing,

-                          struct gl_texture_object *texObj,

-                          struct gl_texture_image *texImage)

-{

-   /* get pointer to src pixels (may be in a pbo which we'll map here) */

-   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,

-                                        type, pixels, packing,

-                                        "glTexSubImage3D");

-   if (!pixels)

-      return;

-

-   {

-      GLint dstRowStride = texture_row_stride(texImage);

-      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,

-                                         texImage->TexFormat,

-                                         texImage->Data,

-                                         xoffset, yoffset, zoffset,

-                                         dstRowStride,

-                                         texImage->ImageOffsets,

-                                         width, height, depth,

-                                         format, type, pixels, packing);

-      if (!success) {

-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage3D");

-      }

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, packing);

-}

-

-

-/*

- * Fallback for Driver.CompressedTexImage1D()

- */

-void

-_mesa_store_compressed_teximage1d(struct gl_context *ctx,

-                                  GLenum target, GLint level,

-                                  GLint internalFormat,

-                                  GLint width, GLint border,

-                                  GLsizei imageSize, const GLvoid *data,

-                                  struct gl_texture_object *texObj,

-                                  struct gl_texture_image *texImage)

-{

-   /* this space intentionally left blank */

-   (void) ctx;

-   (void) target; (void) level;

-   (void) internalFormat;

-   (void) width; (void) border;

-   (void) imageSize; (void) data;

-   (void) texObj;

-   (void) texImage;

-}

-

-

-

-/**

- * Fallback for Driver.CompressedTexImage2D()

- */

-void

-_mesa_store_compressed_teximage2d(struct gl_context *ctx,

-                                  GLenum target, GLint level,

-                                  GLint internalFormat,

-                                  GLint width, GLint height, GLint border,

-                                  GLsizei imageSize, const GLvoid *data,

-                                  struct gl_texture_object *texObj,

-                                  struct gl_texture_image *texImage)

-{

-   (void) width; (void) height; (void) border;

-

-   /* This is pretty simple, basically just do a memcpy without worrying

-    * about the usual image unpacking or image transfer operations.

-    */

-   ASSERT(texObj);

-   ASSERT(texImage);

-   ASSERT(texImage->Width > 0);

-   ASSERT(texImage->Height > 0);

-   ASSERT(texImage->Depth == 1);

-   ASSERT(texImage->Data == NULL); /* was freed in glCompressedTexImage2DARB */

-

-   /* allocate storage */

-   texImage->Data = _mesa_alloc_texmemory(imageSize);

-   if (!texImage->Data) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");

-      return;

-   }

-

-   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,

-                                                 &ctx->Unpack,

-                                                 "glCompressedTexImage2D");

-   if (!data)

-      return;

-

-   /* copy the data */

-   memcpy(texImage->Data, data, imageSize);

-

-   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);

-}

-

-

-

-/*

- * Fallback for Driver.CompressedTexImage3D()

- */

-void

-_mesa_store_compressed_teximage3d(struct gl_context *ctx,

-                                  GLenum target, GLint level,

-                                  GLint internalFormat,

-                                  GLint width, GLint height, GLint depth,

-                                  GLint border,

-                                  GLsizei imageSize, const GLvoid *data,

-                                  struct gl_texture_object *texObj,

-                                  struct gl_texture_image *texImage)

-{

-   /* this space intentionally left blank */

-   (void) ctx;

-   (void) target; (void) level;

-   (void) internalFormat;

-   (void) width; (void) height; (void) depth;

-   (void) border;

-   (void) imageSize; (void) data;

-   (void) texObj;

-   (void) texImage;

-}

-

-

-

-/**

- * Fallback for Driver.CompressedTexSubImage1D()

- */

-void

-_mesa_store_compressed_texsubimage1d(struct gl_context *ctx, GLenum target,

-                                     GLint level,

-                                     GLint xoffset, GLsizei width,

-                                     GLenum format,

-                                     GLsizei imageSize, const GLvoid *data,

-                                     struct gl_texture_object *texObj,

-                                     struct gl_texture_image *texImage)

-{

-   /* there are no compressed 1D texture formats yet */

-   (void) ctx;

-   (void) target; (void) level;

-   (void) xoffset; (void) width;

-   (void) format;

-   (void) imageSize; (void) data;

-   (void) texObj;

-   (void) texImage;

-}

-

-

-/**

- * Fallback for Driver.CompressedTexSubImage2D()

- */

-void

-_mesa_store_compressed_texsubimage2d(struct gl_context *ctx, GLenum target,

-                                     GLint level,

-                                     GLint xoffset, GLint yoffset,

-                                     GLsizei width, GLsizei height,

-                                     GLenum format,

-                                     GLsizei imageSize, const GLvoid *data,

-                                     struct gl_texture_object *texObj,

-                                     struct gl_texture_image *texImage)

-{

-   GLint bytesPerRow, destRowStride, srcRowStride;

-   GLint i, rows;

-   GLubyte *dest;

-   const GLubyte *src;

-   const gl_format texFormat = texImage->TexFormat;

-   const GLint destWidth = texImage->Width;

-   GLuint bw, bh;

-

-   _mesa_get_format_block_size(texFormat, &bw, &bh);

-

-   (void) level;

-   (void) format;

-

-   /* these should have been caught sooner */

-   ASSERT((width % bw) == 0 || width == 2 || width == 1);

-   ASSERT((height % bh) == 0 || height == 2 || height == 1);

-   ASSERT((xoffset % bw) == 0);

-   ASSERT((yoffset % bh) == 0);

-

-   /* get pointer to src pixels (may be in a pbo which we'll map here) */

-   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,

-                                                 &ctx->Unpack,

-                                                 "glCompressedTexSubImage2D");

-   if (!data)

-      return;

-

-   srcRowStride = _mesa_format_row_stride(texFormat, width);

-   src = (const GLubyte *) data;

-

-   destRowStride = _mesa_format_row_stride(texFormat, destWidth);

-   dest = _mesa_compressed_image_address(xoffset, yoffset, 0,

-                                         texFormat, destWidth,

-                                         (GLubyte *) texImage->Data);

-

-   bytesPerRow = srcRowStride;  /* bytes per row of blocks */

-   rows = height / bh;  /* rows in blocks */

-

-   /* copy rows of blocks */

-   for (i = 0; i < rows; i++) {

-      memcpy(dest, src, bytesPerRow);

-      dest += destRowStride;

-      src += srcRowStride;

-   }

-

-   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);

-}

-

-

-/**

- * Fallback for Driver.CompressedTexSubImage3D()

- */

-void

-_mesa_store_compressed_texsubimage3d(struct gl_context *ctx, GLenum target,

-                                GLint level,

-                                GLint xoffset, GLint yoffset, GLint zoffset,

-                                GLsizei width, GLsizei height, GLsizei depth,

-                                GLenum format,

-                                GLsizei imageSize, const GLvoid *data,

-                                struct gl_texture_object *texObj,

-                                struct gl_texture_image *texImage)

-{

-   /* there are no compressed 3D texture formats yet */

-   (void) ctx;

-   (void) target; (void) level;

-   (void) xoffset; (void) yoffset; (void) zoffset;

-   (void) width; (void) height; (void) depth;

-   (void) format;

-   (void) imageSize; (void) data;

-   (void) texObj;

-   (void) texImage;

-}

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.5
+ *
+ * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
+ * Copyright (c) 2008-2009  VMware, Inc.
+ *
+ * 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 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
+ * BRIAN PAUL 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:
+ *   Brian Paul
+ */
+
+/**
+ * The GL texture image functions in teximage.c basically just do
+ * error checking and data structure allocation.  They in turn call
+ * device driver functions which actually copy/convert/store the user's
+ * texture image data.
+ *
+ * However, most device drivers will be able to use the fallback functions
+ * in this file.  That is, most drivers will have the following bit of
+ * code:
+ *   ctx->Driver.TexImage1D = _mesa_store_teximage1d;
+ *   ctx->Driver.TexImage2D = _mesa_store_teximage2d;
+ *   ctx->Driver.TexImage3D = _mesa_store_teximage3d;
+ *   etc...
+ *
+ * Texture image processing is actually kind of complicated.  We have to do:
+ *    Format/type conversions
+ *    pixel unpacking
+ *    pixel transfer (scale, bais, lookup, etc)
+ *
+ * These functions can handle most everything, including processing full
+ * images and sub-images.
+ */
+
+
+#include "glheader.h"
+#include "bufferobj.h"
+#include "colormac.h"
+#include "image.h"
+#include "macros.h"
+#include "mipmap.h"
+#include "mfeatures.h"
+#include "mtypes.h"
+#include "pack.h"
+#include "pbo.h"
+#include "imports.h"
+#include "texcompress.h"
+#include "texcompress_fxt1.h"
+#include "texcompress_rgtc.h"
+#include "texcompress_s3tc.h"
+#include "teximage.h"
+#include "texstore.h"
+#include "enums.h"
+#include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
+#include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
+
+
+enum {
+   ZERO = 4, 
+   ONE = 5
+};
+
+
+/**
+ * Texture image storage function.
+ */
+typedef GLboolean (*StoreTexImageFunc)(TEXSTORE_PARAMS);
+
+
+/**
+ * Return GL_TRUE if the given image format is one that be converted
+ * to another format by swizzling.
+ */
+static GLboolean
+can_swizzle(GLenum logicalBaseFormat)
+{
+   switch (logicalBaseFormat) {
+   case GL_RGBA:
+   case GL_RGB:
+   case GL_LUMINANCE_ALPHA:
+   case GL_INTENSITY:
+   case GL_ALPHA:
+   case GL_LUMINANCE:
+   case GL_RED:
+   case GL_GREEN:
+   case GL_BLUE:
+   case GL_BGR:
+   case GL_BGRA:
+   case GL_ABGR_EXT:
+   case GL_RG:
+      return GL_TRUE;
+   default:
+      return GL_FALSE;
+   }
+}
+
+
+
+enum {
+   IDX_LUMINANCE = 0,
+   IDX_ALPHA,
+   IDX_INTENSITY,
+   IDX_LUMINANCE_ALPHA,
+   IDX_RGB,
+   IDX_RGBA,
+   IDX_RED,
+   IDX_GREEN,
+   IDX_BLUE,
+   IDX_BGR,
+   IDX_BGRA,
+   IDX_ABGR,
+   IDX_RG,
+   MAX_IDX
+};
+
+#define MAP1(x)       MAP4(x, ZERO, ZERO, ZERO)
+#define MAP2(x,y)     MAP4(x, y, ZERO, ZERO)
+#define MAP3(x,y,z)   MAP4(x, y, z, ZERO)
+#define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE }
+
+
+static const struct {
+   GLubyte format_idx;
+   GLubyte to_rgba[6];
+   GLubyte from_rgba[6];
+} mappings[MAX_IDX] = 
+{
+   {
+      IDX_LUMINANCE,
+      MAP4(0,0,0,ONE),
+      MAP1(0)
+   },
+
+   {
+      IDX_ALPHA,
+      MAP4(ZERO, ZERO, ZERO, 0),
+      MAP1(3)
+   },
+
+   {
+      IDX_INTENSITY,
+      MAP4(0, 0, 0, 0),
+      MAP1(0),
+   },
+
+   {
+      IDX_LUMINANCE_ALPHA,
+      MAP4(0,0,0,1),
+      MAP2(0,3)
+   },
+
+   {
+      IDX_RGB,
+      MAP4(0,1,2,ONE),
+      MAP3(0,1,2)
+   },
+
+   {
+      IDX_RGBA,
+      MAP4(0,1,2,3),
+      MAP4(0,1,2,3),
+   },
+
+   {
+      IDX_RED,
+      MAP4(0, ZERO, ZERO, ONE),
+      MAP1(0),
+   },
+
+   {
+      IDX_GREEN,
+      MAP4(ZERO, 0, ZERO, ONE),
+      MAP1(1),
+   },
+
+   {
+      IDX_BLUE,
+      MAP4(ZERO, ZERO, 0, ONE),
+      MAP1(2),
+   },
+
+   {
+      IDX_BGR,
+      MAP4(2,1,0,ONE),
+      MAP3(2,1,0)
+   },
+
+   {
+      IDX_BGRA,
+      MAP4(2,1,0,3),
+      MAP4(2,1,0,3)
+   },
+
+   {
+      IDX_ABGR,
+      MAP4(3,2,1,0),
+      MAP4(3,2,1,0)
+   },
+
+   {
+      IDX_RG,
+      MAP4(0, 1, ZERO, ONE),
+      MAP2(0, 1)
+   },
+};
+
+
+
+/**
+ * Convert a GL image format enum to an IDX_* value (see above).
+ */
+static int
+get_map_idx(GLenum value)
+{
+   switch (value) {
+   case GL_LUMINANCE: return IDX_LUMINANCE;
+   case GL_ALPHA: return IDX_ALPHA;
+   case GL_INTENSITY: return IDX_INTENSITY;
+   case GL_LUMINANCE_ALPHA: return IDX_LUMINANCE_ALPHA;
+   case GL_RGB: return IDX_RGB;
+   case GL_RGBA: return IDX_RGBA;
+   case GL_RED: return IDX_RED;
+   case GL_GREEN: return IDX_GREEN;
+   case GL_BLUE: return IDX_BLUE;
+   case GL_BGR: return IDX_BGR;
+   case GL_BGRA: return IDX_BGRA;
+   case GL_ABGR_EXT: return IDX_ABGR;
+   case GL_RG: return IDX_RG;
+   default:
+      _mesa_problem(NULL, "Unexpected inFormat");
+      return 0;
+   }
+}   
+
+
+/**
+ * When promoting texture formats (see below) we need to compute the
+ * mapping of dest components back to source components.
+ * This function does that.
+ * \param inFormat  the incoming format of the texture
+ * \param outFormat  the final texture format
+ * \return map[6]  a full 6-component map
+ */
+static void
+compute_component_mapping(GLenum inFormat, GLenum outFormat, 
+			  GLubyte *map)
+{
+   const int inFmt = get_map_idx(inFormat);
+   const int outFmt = get_map_idx(outFormat);
+   const GLubyte *in2rgba = mappings[inFmt].to_rgba;
+   const GLubyte *rgba2out = mappings[outFmt].from_rgba;
+   int i;
+   
+   for (i = 0; i < 4; i++)
+      map[i] = in2rgba[rgba2out[i]];
+
+   map[ZERO] = ZERO;
+   map[ONE] = ONE;   
+
+#if 0
+   printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n",
+	  inFormat, _mesa_lookup_enum_by_nr(inFormat),
+	  outFormat, _mesa_lookup_enum_by_nr(outFormat),
+	  map[0], 
+	  map[1], 
+	  map[2], 
+	  map[3], 
+	  map[4], 
+	  map[5]); 
+#endif
+}
+
+
+/**
+ * Make a temporary (color) texture image with GLfloat components.
+ * Apply all needed pixel unpacking and pixel transfer operations.
+ * Note that there are both logicalBaseFormat and textureBaseFormat parameters.
+ * Suppose the user specifies GL_LUMINANCE as the internal texture format
+ * but the graphics hardware doesn't support luminance textures.  So, we might
+ * use an RGB hardware format instead.
+ * If logicalBaseFormat != textureBaseFormat we have some extra work to do.
+ *
+ * \param ctx  the rendering context
+ * \param dims  image dimensions: 1, 2 or 3
+ * \param logicalBaseFormat  basic texture derived from the user's
+ *    internal texture format value
+ * \param textureBaseFormat  the actual basic format of the texture
+ * \param srcWidth  source image width
+ * \param srcHeight  source image height
+ * \param srcDepth  source image depth
+ * \param srcFormat  source image format
+ * \param srcType  source image type
+ * \param srcAddr  source image address
+ * \param srcPacking  source image pixel packing
+ * \return resulting image with format = textureBaseFormat and type = GLfloat.
+ */
+GLfloat *
+_mesa_make_temp_float_image(struct gl_context *ctx, GLuint dims,
+			    GLenum logicalBaseFormat,
+			    GLenum textureBaseFormat,
+			    GLint srcWidth, GLint srcHeight, GLint srcDepth,
+			    GLenum srcFormat, GLenum srcType,
+			    const GLvoid *srcAddr,
+			    const struct gl_pixelstore_attrib *srcPacking,
+			    GLbitfield transferOps)
+{
+   GLfloat *tempImage;
+   const GLint components = _mesa_components_in_format(logicalBaseFormat);
+   const GLint srcStride =
+      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+   GLfloat *dst;
+   GLint img, row;
+
+   ASSERT(dims >= 1 && dims <= 3);
+
+   ASSERT(logicalBaseFormat == GL_RGBA ||
+          logicalBaseFormat == GL_RGB ||
+          logicalBaseFormat == GL_RG ||
+          logicalBaseFormat == GL_RED ||
+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
+          logicalBaseFormat == GL_LUMINANCE ||
+          logicalBaseFormat == GL_ALPHA ||
+          logicalBaseFormat == GL_INTENSITY ||
+          logicalBaseFormat == GL_COLOR_INDEX ||
+          logicalBaseFormat == GL_DEPTH_COMPONENT);
+
+   ASSERT(textureBaseFormat == GL_RGBA ||
+          textureBaseFormat == GL_RGB ||
+          textureBaseFormat == GL_RG ||
+          textureBaseFormat == GL_RED ||
+          textureBaseFormat == GL_LUMINANCE_ALPHA ||
+          textureBaseFormat == GL_LUMINANCE ||
+          textureBaseFormat == GL_ALPHA ||
+          textureBaseFormat == GL_INTENSITY ||
+          textureBaseFormat == GL_COLOR_INDEX ||
+          textureBaseFormat == GL_DEPTH_COMPONENT);
+
+   tempImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
+				  * components * sizeof(GLfloat));
+   if (!tempImage)
+      return NULL;
+
+   dst = tempImage;
+   for (img = 0; img < srcDepth; img++) {
+      const GLubyte *src
+	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+						 srcWidth, srcHeight,
+						 srcFormat, srcType,
+						 img, 0, 0);
+      for (row = 0; row < srcHeight; row++) {
+	 _mesa_unpack_color_span_float(ctx, srcWidth, logicalBaseFormat,
+				       dst, srcFormat, srcType, src,
+				       srcPacking, transferOps);
+	 dst += srcWidth * components;
+	 src += srcStride;
+      }
+   }
+
+   if (logicalBaseFormat != textureBaseFormat) {
+      /* more work */
+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
+      GLfloat *newImage;
+      GLint i, n;
+      GLubyte map[6];
+
+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
+             textureBaseFormat == GL_LUMINANCE_ALPHA);
+
+      /* The actual texture format should have at least as many components
+       * as the logical texture format.
+       */
+      ASSERT(texComponents >= logComponents);
+
+      newImage = (GLfloat *) malloc(srcWidth * srcHeight * srcDepth
+                                          * texComponents * sizeof(GLfloat));
+      if (!newImage) {
+         free(tempImage);
+         return NULL;
+      }
+
+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
+
+      n = srcWidth * srcHeight * srcDepth;
+      for (i = 0; i < n; i++) {
+         GLint k;
+         for (k = 0; k < texComponents; k++) {
+            GLint j = map[k];
+            if (j == ZERO)
+               newImage[i * texComponents + k] = 0.0F;
+            else if (j == ONE)
+               newImage[i * texComponents + k] = 1.0F;
+            else
+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
+         }
+      }
+
+      free(tempImage);
+      tempImage = newImage;
+   }
+
+   return tempImage;
+}
+
+
+/**
+ * Make temporary image with uint pixel values.  Used for unsigned
+ * integer-valued textures.
+ */
+static GLuint *
+make_temp_uint_image(struct gl_context *ctx, GLuint dims,
+                     GLenum logicalBaseFormat,
+                     GLenum textureBaseFormat,
+                     GLint srcWidth, GLint srcHeight, GLint srcDepth,
+                     GLenum srcFormat, GLenum srcType,
+                     const GLvoid *srcAddr,
+                     const struct gl_pixelstore_attrib *srcPacking)
+{
+   GLuint *tempImage;
+   const GLint components = _mesa_components_in_format(logicalBaseFormat);
+   const GLint srcStride =
+      _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+   GLuint *dst;
+   GLint img, row;
+
+   ASSERT(dims >= 1 && dims <= 3);
+
+   ASSERT(logicalBaseFormat == GL_RGBA ||
+          logicalBaseFormat == GL_RGB ||
+          logicalBaseFormat == GL_RG ||
+          logicalBaseFormat == GL_RED ||
+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
+          logicalBaseFormat == GL_LUMINANCE ||
+          logicalBaseFormat == GL_INTENSITY ||
+          logicalBaseFormat == GL_ALPHA);
+
+   ASSERT(textureBaseFormat == GL_RGBA ||
+          textureBaseFormat == GL_RGB ||
+          textureBaseFormat == GL_RG ||
+          textureBaseFormat == GL_RED ||
+          textureBaseFormat == GL_LUMINANCE_ALPHA ||
+          textureBaseFormat == GL_LUMINANCE ||
+          textureBaseFormat == GL_ALPHA);
+
+   tempImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth
+                                 * components * sizeof(GLuint));
+   if (!tempImage)
+      return NULL;
+
+   dst = tempImage;
+   for (img = 0; img < srcDepth; img++) {
+      const GLubyte *src
+	 = (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+						 srcWidth, srcHeight,
+						 srcFormat, srcType,
+						 img, 0, 0);
+      for (row = 0; row < srcHeight; row++) {
+	 _mesa_unpack_color_span_uint(ctx, srcWidth, logicalBaseFormat,
+                                      dst, srcFormat, srcType, src,
+                                      srcPacking);
+	 dst += srcWidth * components;
+	 src += srcStride;
+      }
+   }
+
+   if (logicalBaseFormat != textureBaseFormat) {
+      /* more work */
+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
+      GLuint *newImage;
+      GLint i, n;
+      GLubyte map[6];
+
+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
+             textureBaseFormat == GL_LUMINANCE_ALPHA);
+
+      /* The actual texture format should have at least as many components
+       * as the logical texture format.
+       */
+      ASSERT(texComponents >= logComponents);
+
+      newImage = (GLuint *) malloc(srcWidth * srcHeight * srcDepth
+                                   * texComponents * sizeof(GLuint));
+      if (!newImage) {
+         free(tempImage);
+         return NULL;
+      }
+
+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
+
+      n = srcWidth * srcHeight * srcDepth;
+      for (i = 0; i < n; i++) {
+         GLint k;
+         for (k = 0; k < texComponents; k++) {
+            GLint j = map[k];
+            if (j == ZERO)
+               newImage[i * texComponents + k] = 0.0F;
+            else if (j == ONE)
+               newImage[i * texComponents + k] = 1.0F;
+            else
+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
+         }
+      }
+
+      free(tempImage);
+      tempImage = newImage;
+   }
+
+   return tempImage;
+}
+
+
+
+/**
+ * Make a temporary (color) texture image with GLchan components.
+ * Apply all needed pixel unpacking and pixel transfer operations.
+ * Note that there are both logicalBaseFormat and textureBaseFormat parameters.
+ * Suppose the user specifies GL_LUMINANCE as the internal texture format
+ * but the graphics hardware doesn't support luminance textures.  So, we might
+ * use an RGB hardware format instead.
+ * If logicalBaseFormat != textureBaseFormat we have some extra work to do.
+ *
+ * \param ctx  the rendering context
+ * \param dims  image dimensions: 1, 2 or 3
+ * \param logicalBaseFormat  basic texture derived from the user's
+ *    internal texture format value
+ * \param textureBaseFormat  the actual basic format of the texture
+ * \param srcWidth  source image width
+ * \param srcHeight  source image height
+ * \param srcDepth  source image depth
+ * \param srcFormat  source image format
+ * \param srcType  source image type
+ * \param srcAddr  source image address
+ * \param srcPacking  source image pixel packing
+ * \return resulting image with format = textureBaseFormat and type = GLchan.
+ */
+GLchan *
+_mesa_make_temp_chan_image(struct gl_context *ctx, GLuint dims,
+                           GLenum logicalBaseFormat,
+                           GLenum textureBaseFormat,
+                           GLint srcWidth, GLint srcHeight, GLint srcDepth,
+                           GLenum srcFormat, GLenum srcType,
+                           const GLvoid *srcAddr,
+                           const struct gl_pixelstore_attrib *srcPacking)
+{
+   GLuint transferOps = ctx->_ImageTransferState;
+   const GLint components = _mesa_components_in_format(logicalBaseFormat);
+   GLint img, row;
+   GLchan *tempImage, *dst;
+
+   ASSERT(dims >= 1 && dims <= 3);
+
+   ASSERT(logicalBaseFormat == GL_RGBA ||
+          logicalBaseFormat == GL_RGB ||
+          logicalBaseFormat == GL_RG ||
+          logicalBaseFormat == GL_RED ||
+          logicalBaseFormat == GL_LUMINANCE_ALPHA ||
+          logicalBaseFormat == GL_LUMINANCE ||
+          logicalBaseFormat == GL_ALPHA ||
+          logicalBaseFormat == GL_INTENSITY);
+
+   ASSERT(textureBaseFormat == GL_RGBA ||
+          textureBaseFormat == GL_RGB ||
+          textureBaseFormat == GL_RG ||
+          textureBaseFormat == GL_RED ||
+          textureBaseFormat == GL_LUMINANCE_ALPHA ||
+          textureBaseFormat == GL_LUMINANCE ||
+          textureBaseFormat == GL_ALPHA ||
+          textureBaseFormat == GL_INTENSITY);
+
+   /* unpack and transfer the source image */
+   tempImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth
+                                       * components * sizeof(GLchan));
+   if (!tempImage) {
+      return NULL;
+   }
+
+   dst = tempImage;
+   for (img = 0; img < srcDepth; img++) {
+      const GLint srcStride =
+         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+      const GLubyte *src =
+         (const GLubyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+                                               srcWidth, srcHeight,
+                                               srcFormat, srcType,
+                                               img, 0, 0);
+      for (row = 0; row < srcHeight; row++) {
+         _mesa_unpack_color_span_chan(ctx, srcWidth, logicalBaseFormat, dst,
+                                      srcFormat, srcType, src, srcPacking,
+                                      transferOps);
+         dst += srcWidth * components;
+         src += srcStride;
+      }
+   }
+
+   if (logicalBaseFormat != textureBaseFormat) {
+      /* one more conversion step */
+      GLint texComponents = _mesa_components_in_format(textureBaseFormat);
+      GLint logComponents = _mesa_components_in_format(logicalBaseFormat);
+      GLchan *newImage;
+      GLint i, n;
+      GLubyte map[6];
+
+      /* we only promote up to RGB, RGBA and LUMINANCE_ALPHA formats for now */
+      ASSERT(textureBaseFormat == GL_RGB || textureBaseFormat == GL_RGBA ||
+             textureBaseFormat == GL_LUMINANCE_ALPHA);
+
+      /* The actual texture format should have at least as many components
+       * as the logical texture format.
+       */
+      ASSERT(texComponents >= logComponents);
+
+      newImage = (GLchan *) malloc(srcWidth * srcHeight * srcDepth
+                                         * texComponents * sizeof(GLchan));
+      if (!newImage) {
+         free(tempImage);
+         return NULL;
+      }
+
+      compute_component_mapping(logicalBaseFormat, textureBaseFormat, map);
+
+      n = srcWidth * srcHeight * srcDepth;
+      for (i = 0; i < n; i++) {
+         GLint k;
+         for (k = 0; k < texComponents; k++) {
+            GLint j = map[k];
+            if (j == ZERO)
+               newImage[i * texComponents + k] = 0;
+            else if (j == ONE)
+               newImage[i * texComponents + k] = CHAN_MAX;
+            else
+               newImage[i * texComponents + k] = tempImage[i * logComponents + j];
+         }
+      }
+
+      free(tempImage);
+      tempImage = newImage;
+   }
+
+   return tempImage;
+}
+
+
+/**
+ * Copy GLubyte pixels from <src> to <dst> with swizzling.
+ * \param dst  destination pixels
+ * \param dstComponents  number of color components in destination pixels
+ * \param src  source pixels
+ * \param srcComponents  number of color components in source pixels
+ * \param map  the swizzle mapping.  map[X] says where to find the X component
+ *             in the source image's pixels.  For example, if the source image
+ *             is GL_BGRA and X = red, map[0] yields 2.
+ * \param count  number of pixels to copy/swizzle.
+ */
+static void
+swizzle_copy(GLubyte *dst, GLuint dstComponents, const GLubyte *src, 
+             GLuint srcComponents, const GLubyte *map, GLuint count)
+{
+#define SWZ_CPY(dst, src, count, dstComps, srcComps) \
+   do {                                              \
+      GLuint i;                                      \
+      for (i = 0; i < count; i++) {                  \
+         GLuint j;                                   \
+         if (srcComps == 4) {                        \
+            COPY_4UBV(tmp, src);                     \
+         }                                           \
+         else {                                      \
+            for (j = 0; j < srcComps; j++) {         \
+               tmp[j] = src[j];                      \
+            }                                        \
+         }                                           \
+         src += srcComps;                            \
+         for (j = 0; j < dstComps; j++) {            \
+            dst[j] = tmp[map[j]];                    \
+         }                                           \
+         dst += dstComps;                            \
+      }                                              \
+   } while (0)
+
+   GLubyte tmp[6];
+
+   tmp[ZERO] = 0x0;
+   tmp[ONE] = 0xff;
+
+   ASSERT(srcComponents <= 4);
+   ASSERT(dstComponents <= 4);
+
+   switch (dstComponents) {
+   case 4:
+      switch (srcComponents) {
+      case 4:
+         SWZ_CPY(dst, src, count, 4, 4);
+         break;
+      case 3:
+         SWZ_CPY(dst, src, count, 4, 3);
+         break;
+      case 2:
+         SWZ_CPY(dst, src, count, 4, 2);
+         break;
+      case 1:
+         SWZ_CPY(dst, src, count, 4, 1);
+         break;
+      default:
+         ;
+      }
+      break;
+   case 3:
+      switch (srcComponents) {
+      case 4:
+         SWZ_CPY(dst, src, count, 3, 4);
+         break;
+      case 3:
+         SWZ_CPY(dst, src, count, 3, 3);
+         break;
+      case 2:
+         SWZ_CPY(dst, src, count, 3, 2);
+         break;
+      case 1:
+         SWZ_CPY(dst, src, count, 3, 1);
+         break;
+      default:
+         ;
+      }
+      break;
+   case 2:
+      switch (srcComponents) {
+      case 4:
+         SWZ_CPY(dst, src, count, 2, 4);
+         break;
+      case 3:
+         SWZ_CPY(dst, src, count, 2, 3);
+         break;
+      case 2:
+         SWZ_CPY(dst, src, count, 2, 2);
+         break;
+      case 1:
+         SWZ_CPY(dst, src, count, 2, 1);
+         break;
+      default:
+         ;
+      }
+      break;
+   case 1:
+      switch (srcComponents) {
+      case 4:
+         SWZ_CPY(dst, src, count, 1, 4);
+         break;
+      case 3:
+         SWZ_CPY(dst, src, count, 1, 3);
+         break;
+      case 2:
+         SWZ_CPY(dst, src, count, 1, 2);
+         break;
+      case 1:
+         SWZ_CPY(dst, src, count, 1, 1);
+         break;
+      default:
+         ;
+      }
+      break;
+   default:
+      ;
+   }
+#undef SWZ_CPY
+}
+
+
+
+static const GLubyte map_identity[6] = { 0, 1, 2, 3, ZERO, ONE };
+static const GLubyte map_3210[6] = { 3, 2, 1, 0, ZERO, ONE };
+
+
+/**
+ * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a
+ * mapping array depending on endianness.
+ */
+static const GLubyte *
+type_mapping( GLenum srcType )
+{
+   switch (srcType) {
+   case GL_BYTE:
+   case GL_UNSIGNED_BYTE:
+      return map_identity;
+   case GL_UNSIGNED_INT_8_8_8_8:
+      return _mesa_little_endian() ? map_3210 : map_identity;
+   case GL_UNSIGNED_INT_8_8_8_8_REV:
+      return _mesa_little_endian() ? map_identity : map_3210;
+   default:
+      return NULL;
+   }
+}
+
+
+/**
+ * For 1-byte/pixel formats (or 8_8_8_8 packed formats), return a
+ * mapping array depending on pixelstore byte swapping state.
+ */
+static const GLubyte *
+byteswap_mapping( GLboolean swapBytes,
+		  GLenum srcType )
+{
+   if (!swapBytes) 
+      return map_identity;
+
+   switch (srcType) {
+   case GL_BYTE:
+   case GL_UNSIGNED_BYTE:
+      return map_identity;
+   case GL_UNSIGNED_INT_8_8_8_8:
+   case GL_UNSIGNED_INT_8_8_8_8_REV:
+      return map_3210;
+   default:
+      return NULL;
+   }
+}
+
+
+
+/**
+ * Transfer a GLubyte texture image with component swizzling.
+ */
+static void
+_mesa_swizzle_ubyte_image(struct gl_context *ctx, 
+			  GLuint dimensions,
+			  GLenum srcFormat,
+			  GLenum srcType,
+
+			  GLenum baseInternalFormat,
+
+			  const GLubyte *rgba2dst,
+			  GLuint dstComponents,
+
+			  GLvoid *dstAddr,
+			  GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
+			  GLint dstRowStride,
+                          const GLuint *dstImageOffsets,
+
+			  GLint srcWidth, GLint srcHeight, GLint srcDepth,
+			  const GLvoid *srcAddr,
+			  const struct gl_pixelstore_attrib *srcPacking )
+{
+   GLint srcComponents = _mesa_components_in_format(srcFormat);
+   const GLubyte *srctype2ubyte, *swap;
+   GLubyte map[4], src2base[6], base2rgba[6];
+   GLint i;
+   const GLint srcRowStride =
+      _mesa_image_row_stride(srcPacking, srcWidth,
+                             srcFormat, GL_UNSIGNED_BYTE);
+   const GLint srcImageStride
+      = _mesa_image_image_stride(srcPacking, srcWidth, srcHeight, srcFormat,
+                                 GL_UNSIGNED_BYTE);
+   const GLubyte *srcImage
+      = (const GLubyte *) _mesa_image_address(dimensions, srcPacking, srcAddr,
+                                              srcWidth, srcHeight, srcFormat,
+                                              GL_UNSIGNED_BYTE, 0, 0, 0);
+
+   (void) ctx;
+
+   /* Translate from src->baseInternal->GL_RGBA->dst.  This will
+    * correctly deal with RGBA->RGB->RGBA conversions where the final
+    * A value must be 0xff regardless of the incoming alpha values.
+    */
+   compute_component_mapping(srcFormat, baseInternalFormat, src2base);
+   compute_component_mapping(baseInternalFormat, GL_RGBA, base2rgba);
+   swap = byteswap_mapping(srcPacking->SwapBytes, srcType);
+   srctype2ubyte = type_mapping(srcType);
+
+
+   for (i = 0; i < 4; i++)
+      map[i] = srctype2ubyte[swap[src2base[base2rgba[rgba2dst[i]]]]];
+
+/*    printf("map %d %d %d %d\n", map[0], map[1], map[2], map[3]);  */
+
+   if (srcComponents == dstComponents &&
+       srcRowStride == dstRowStride &&
+       srcRowStride == srcWidth * srcComponents &&
+       dimensions < 3) {
+      /* 1 and 2D images only */
+      GLubyte *dstImage = (GLubyte *) dstAddr
+         + dstYoffset * dstRowStride
+         + dstXoffset * dstComponents;
+      swizzle_copy(dstImage, dstComponents, srcImage, srcComponents, map, 
+		   srcWidth * srcHeight);
+   }
+   else {
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         const GLubyte *srcRow = srcImage;
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * dstComponents
+            + dstYoffset * dstRowStride
+            + dstXoffset * dstComponents;
+         for (row = 0; row < srcHeight; row++) {
+	    swizzle_copy(dstRow, dstComponents, srcRow, srcComponents, map, srcWidth);
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+         srcImage += srcImageStride;
+      }
+   }
+}
+
+
+/**
+ * Teximage storage routine for when a simple memcpy will do.
+ * No pixel transfer operations or special texel encodings allowed.
+ * 1D, 2D and 3D images supported.
+ */
+static void
+memcpy_texture(struct gl_context *ctx,
+	       GLuint dimensions,
+               gl_format dstFormat,
+               GLvoid *dstAddr,
+               GLint dstXoffset, GLint dstYoffset, GLint dstZoffset,
+               GLint dstRowStride,
+               const GLuint *dstImageOffsets,
+               GLint srcWidth, GLint srcHeight, GLint srcDepth,
+               GLenum srcFormat, GLenum srcType,
+               const GLvoid *srcAddr,
+               const struct gl_pixelstore_attrib *srcPacking)
+{
+   const GLint srcRowStride = _mesa_image_row_stride(srcPacking, srcWidth,
+                                                     srcFormat, srcType);
+   const GLint srcImageStride = _mesa_image_image_stride(srcPacking,
+                                      srcWidth, srcHeight, srcFormat, srcType);
+   const GLubyte *srcImage = (const GLubyte *) _mesa_image_address(dimensions,
+        srcPacking, srcAddr, srcWidth, srcHeight, srcFormat, srcType, 0, 0, 0);
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLint bytesPerRow = srcWidth * texelBytes;
+
+#if 0
+   /* XXX update/re-enable for dstImageOffsets array */
+   const GLint bytesPerImage = srcHeight * bytesPerRow;
+   const GLint bytesPerTexture = srcDepth * bytesPerImage;
+   GLubyte *dstImage = (GLubyte *) dstAddr
+                     + dstZoffset * dstImageStride
+                     + dstYoffset * dstRowStride
+                     + dstXoffset * texelBytes;
+
+   if (dstRowStride == srcRowStride &&
+       dstRowStride == bytesPerRow &&
+       ((dstImageStride == srcImageStride &&
+         dstImageStride == bytesPerImage) ||
+        (srcDepth == 1))) {
+      /* one big memcpy */
+      ctx->Driver.TextureMemCpy(dstImage, srcImage, bytesPerTexture);
+   }
+   else
+   {
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         const GLubyte *srcRow = srcImage;
+         GLubyte *dstRow = dstImage;
+         for (row = 0; row < srcHeight; row++) {
+            ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+         srcImage += srcImageStride;
+         dstImage += dstImageStride;
+      }
+   }
+#endif
+
+   GLint img, row;
+   for (img = 0; img < srcDepth; img++) {
+      const GLubyte *srcRow = srcImage;
+      GLubyte *dstRow = (GLubyte *) dstAddr
+         + dstImageOffsets[dstZoffset + img] * texelBytes
+         + dstYoffset * dstRowStride
+         + dstXoffset * texelBytes;
+      for (row = 0; row < srcHeight; row++) {
+         ctx->Driver.TextureMemCpy(dstRow, srcRow, bytesPerRow);
+         dstRow += dstRowStride;
+         srcRow += srcRowStride;
+      }
+      srcImage += srcImageStride;
+   }
+}
+
+
+
+/**
+ * Store a 32-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_z32(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffffff;
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   (void) dims;
+   ASSERT(dstFormat == MESA_FORMAT_Z32);
+   ASSERT(texelBytes == sizeof(GLuint));
+
+   if (ctx->Pixel.DepthScale == 1.0f &&
+       ctx->Pixel.DepthBias == 0.0f &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_DEPTH_COMPONENT &&
+       srcFormat == GL_DEPTH_COMPONENT &&
+       srcType == GL_UNSIGNED_INT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_INT, (GLuint *) dstRow,
+                                    depthScale, srcType, src, srcPacking);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a 24-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_x8_z24(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffff;
+   const GLuint texelBytes = 4;
+
+   (void) dims;
+   ASSERT(dstFormat == MESA_FORMAT_X8_Z24);
+
+   {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_INT, (GLuint *) dstRow,
+                                    depthScale, srcType, src, srcPacking);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a 24-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_z24_x8(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffff;
+   const GLuint texelBytes = 4;
+
+   (void) dims;
+   ASSERT(dstFormat == MESA_FORMAT_Z24_X8);
+
+   {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            GLuint *dst = (GLuint *) dstRow;
+            GLint i;
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_INT, dst,
+                                    depthScale, srcType, src, srcPacking);
+            for (i = 0; i < srcWidth; i++)
+               dst[i] <<= 8;
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a 16-bit integer depth component texture image.
+ */
+static GLboolean
+_mesa_texstore_z16(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffff;
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   (void) dims;
+   ASSERT(dstFormat == MESA_FORMAT_Z16);
+   ASSERT(texelBytes == sizeof(GLushort));
+
+   if (ctx->Pixel.DepthScale == 1.0f &&
+       ctx->Pixel.DepthBias == 0.0f &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_DEPTH_COMPONENT &&
+       srcFormat == GL_DEPTH_COMPONENT &&
+       srcType == GL_UNSIGNED_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            GLushort *dst16 = (GLushort *) dstRow;
+            _mesa_unpack_depth_span(ctx, srcWidth,
+                                    GL_UNSIGNED_SHORT, dst16, depthScale,
+                                    srcType, src, srcPacking);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store an rgb565 or rgb565_rev texture image.
+ */
+static GLboolean
+_mesa_texstore_rgb565(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGB565 ||
+          dstFormat == MESA_FORMAT_RGB565_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_RGB565 &&
+       baseInternalFormat == GL_RGB &&
+       srcFormat == GL_RGB &&
+       srcType == GL_UNSIGNED_SHORT_5_6_5) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+            baseInternalFormat == GL_RGB &&
+            srcFormat == GL_RGB &&
+            srcType == GL_UNSIGNED_BYTE &&
+            dims == 2) {
+      /* do optimized tex store */
+      const GLint srcRowStride =
+         _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+      const GLubyte *src = (const GLubyte *)
+         _mesa_image_address(dims, srcPacking, srcAddr, srcWidth, srcHeight,
+                             srcFormat, srcType, 0, 0, 0);
+      GLubyte *dst = (GLubyte *) dstAddr
+                   + dstYoffset * dstRowStride
+                   + dstXoffset * texelBytes;
+      GLint row, col;
+      for (row = 0; row < srcHeight; row++) {
+         const GLubyte *srcUB = (const GLubyte *) src;
+         GLushort *dstUS = (GLushort *) dst;
+         /* check for byteswapped format */
+         if (dstFormat == MESA_FORMAT_RGB565) {
+            for (col = 0; col < srcWidth; col++) {
+               dstUS[col] = PACK_COLOR_565( srcUB[0], srcUB[1], srcUB[2] );
+               srcUB += 3;
+            }
+         }
+         else {
+            for (col = 0; col < srcWidth; col++) {
+               dstUS[col] = PACK_COLOR_565_REV( srcUB[0], srcUB[1], srcUB[2] );
+               srcUB += 3;
+            }
+         }
+         dst += dstRowStride;
+         src += srcRowStride;
+      }
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            /* check for byteswapped format */
+            if (dstFormat == MESA_FORMAT_RGB565) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_565( CHAN_TO_UBYTE(src[RCOMP]),
+                                               CHAN_TO_UBYTE(src[GCOMP]),
+                                               CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 3;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_565_REV( CHAN_TO_UBYTE(src[RCOMP]),
+                                                   CHAN_TO_UBYTE(src[GCOMP]),
+                                                   CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 3;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a texture in MESA_FORMAT_RGBA8888 or MESA_FORMAT_RGBA8888_REV.
+ */
+static GLboolean
+_mesa_texstore_rgba8888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA8888 ||
+          dstFormat == MESA_FORMAT_RGBA8888_REV);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_RGBA8888 &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8) ||
+       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && !littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && littleEndian))) {
+       /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_RGBA8888_REV &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_UNSIGNED_INT_8_8_8_8_REV) ||
+       (srcFormat == GL_RGBA && srcType == GL_UNSIGNED_BYTE && littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_INT_8_8_8_8) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_UNSIGNED_BYTE && !littleEndian))) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+	    (srcType == GL_UNSIGNED_BYTE ||
+	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if ((littleEndian && dstFormat == MESA_FORMAT_RGBA8888) ||
+	  (!littleEndian && dstFormat == MESA_FORMAT_RGBA8888_REV)) {
+	 dstmap[3] = 0;
+	 dstmap[2] = 1;
+	 dstmap[1] = 2;
+	 dstmap[0] = 3;
+      }
+      else {
+	 dstmap[3] = 3;
+	 dstmap[2] = 2;
+	 dstmap[1] = 1;
+	 dstmap[0] = 0;
+      }
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 4,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint *) dstRow;
+            if (dstFormat == MESA_FORMAT_RGBA8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]),
+                                                CHAN_TO_UBYTE(src[ACOMP]) );
+                  src += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[RCOMP]),
+                                                    CHAN_TO_UBYTE(src[GCOMP]),
+                                                    CHAN_TO_UBYTE(src[BCOMP]),
+                                                    CHAN_TO_UBYTE(src[ACOMP]) );
+                  src += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_argb8888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = GL_RGBA;
+
+   ASSERT(dstFormat == MESA_FORMAT_ARGB8888 ||
+          dstFormat == MESA_FORMAT_ARGB8888_REV ||
+          dstFormat == MESA_FORMAT_XRGB8888 ||
+          dstFormat == MESA_FORMAT_XRGB8888_REV );
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       (dstFormat == MESA_FORMAT_ARGB8888 ||
+        dstFormat == MESA_FORMAT_XRGB8888) &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_BGRA &&
+       ((srcType == GL_UNSIGNED_BYTE && littleEndian) ||
+        srcType == GL_UNSIGNED_INT_8_8_8_8_REV)) {
+      /* simple memcpy path (little endian) */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       (dstFormat == MESA_FORMAT_ARGB8888_REV ||
+        dstFormat == MESA_FORMAT_XRGB8888_REV) &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_BGRA &&
+       ((srcType == GL_UNSIGNED_BYTE && !littleEndian) ||
+        srcType == GL_UNSIGNED_INT_8_8_8_8)) {
+      /* simple memcpy path (big endian) */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+	    (dstFormat == MESA_FORMAT_ARGB8888 ||
+             dstFormat == MESA_FORMAT_XRGB8888) &&
+            srcFormat == GL_RGB &&
+	    (baseInternalFormat == GL_RGBA ||
+	     baseInternalFormat == GL_RGB) &&
+            srcType == GL_UNSIGNED_BYTE) {
+      int img, row, col;
+      for (img = 0; img < srcDepth; img++) {
+         const GLint srcRowStride =
+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *d4 = (GLuint *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               d4[col] = PACK_COLOR_8888(0xff,
+                                         srcRow[col * 3 + RCOMP],
+                                         srcRow[col * 3 + GCOMP],
+                                         srcRow[col * 3 + BCOMP]);
+            }
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+      }
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+	    dstFormat == MESA_FORMAT_ARGB8888 &&
+            srcFormat == GL_RGBA &&
+	    baseInternalFormat == GL_RGBA &&
+            srcType == GL_UNSIGNED_BYTE) {
+      /* same as above case, but src data has alpha too */
+      GLint img, row, col;
+      /* For some reason, streaming copies to write-combined regions
+       * are extremely sensitive to the characteristics of how the
+       * source data is retrieved.  By reordering the source reads to
+       * be in-order, the speed of this operation increases by half.
+       * Strangely the same isn't required for the RGB path, above.
+       */
+      for (img = 0; img < srcDepth; img++) {
+         const GLint srcRowStride =
+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *d4 = (GLuint *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               d4[col] = PACK_COLOR_8888(srcRow[col * 4 + ACOMP],
+                                         srcRow[col * 4 + RCOMP],
+                                         srcRow[col * 4 + GCOMP],
+                                         srcRow[col * 4 + BCOMP]);
+            }
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+      }
+   }
+   else if (!ctx->_ImageTransferState &&
+	    (srcType == GL_UNSIGNED_BYTE ||
+	     srcType == GL_UNSIGNED_INT_8_8_8_8 ||
+	     srcType == GL_UNSIGNED_INT_8_8_8_8_REV) &&
+	    can_swizzle(baseInternalFormat) &&	   
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if ((littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
+          (littleEndian && dstFormat == MESA_FORMAT_XRGB8888) ||
+	  (!littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
+	  (!littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV)) {
+	 dstmap[3] = 3;		/* alpha */
+	 dstmap[2] = 0;		/* red */
+	 dstmap[1] = 1;		/* green */
+	 dstmap[0] = 2;		/* blue */
+      }
+      else {
+	 assert((littleEndian && dstFormat == MESA_FORMAT_ARGB8888_REV) ||
+		(!littleEndian && dstFormat == MESA_FORMAT_ARGB8888) ||
+		(littleEndian && dstFormat == MESA_FORMAT_XRGB8888_REV) ||
+		(!littleEndian && dstFormat == MESA_FORMAT_XRGB8888));
+	 dstmap[3] = 2;
+	 dstmap[2] = 1;
+	 dstmap[1] = 0;
+	 dstmap[0] = 3;
+      }
+ 
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 4,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride,
+                                dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint *) dstRow;
+            if (dstFormat == MESA_FORMAT_ARGB8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888( CHAN_TO_UBYTE(src[ACOMP]),
+                                                CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            else if (dstFormat == MESA_FORMAT_XRGB8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888( 0xff,
+                                                CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUI[col] = PACK_COLOR_8888_REV( CHAN_TO_UBYTE(src[ACOMP]),
+                                                    CHAN_TO_UBYTE(src[RCOMP]),
+                                                    CHAN_TO_UBYTE(src[GCOMP]),
+                                                    CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_rgb888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGB888);
+   ASSERT(texelBytes == 3);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGB &&
+       srcFormat == GL_BGR &&
+       srcType == GL_UNSIGNED_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+            srcFormat == GL_RGBA &&
+            srcType == GL_UNSIGNED_BYTE) {
+      /* extract RGB from RGBA */
+      GLint img, row, col;
+      for (img = 0; img < srcDepth; img++) {
+         const GLint srcRowStride =
+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col * 3 + 0] = srcRow[col * 4 + BCOMP];
+               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];
+               dstRow[col * 3 + 2] = srcRow[col * 4 + RCOMP];
+            }
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+      }
+   }
+   else if (!ctx->_ImageTransferState &&
+	    srcType == GL_UNSIGNED_BYTE &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      dstmap[0] = 2;
+      dstmap[1] = 1;
+      dstmap[2] = 0;
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 3,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = (const GLchan *) tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+#if 0
+            if (littleEndian) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);
+                  dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
+                  dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);
+                  srcUB += 3;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstRow[col * 3 + 0] = srcUB[BCOMP];
+                  dstRow[col * 3 + 1] = srcUB[GCOMP];
+                  dstRow[col * 3 + 2] = srcUB[RCOMP];
+                  srcUB += 3;
+               }
+            }
+#else
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[BCOMP]);
+               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
+               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[RCOMP]);
+               src += 3;
+            }
+#endif
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_bgr888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_BGR888);
+   ASSERT(texelBytes == 3);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGB &&
+       srcFormat == GL_RGB &&
+       srcType == GL_UNSIGNED_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+            !srcPacking->SwapBytes &&
+            srcFormat == GL_RGBA &&
+            srcType == GL_UNSIGNED_BYTE) {
+      /* extract BGR from RGBA */
+      int img, row, col;
+      for (img = 0; img < srcDepth; img++) {
+         const GLint srcRowStride =
+            _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType);
+         GLubyte *srcRow = (GLubyte *) _mesa_image_address(dims, srcPacking,
+                  srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, 0, 0);
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col * 3 + 0] = srcRow[col * 4 + RCOMP];
+               dstRow[col * 3 + 1] = srcRow[col * 4 + GCOMP];
+               dstRow[col * 3 + 2] = srcRow[col * 4 + BCOMP];
+            }
+            dstRow += dstRowStride;
+            srcRow += srcRowStride;
+         }
+      }
+   }
+   else if (!ctx->_ImageTransferState &&
+	    srcType == GL_UNSIGNED_BYTE &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      dstmap[0] = 0;
+      dstmap[1] = 1;
+      dstmap[2] = 2;
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 3,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = (const GLchan *) tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col * 3 + 0] = CHAN_TO_UBYTE(src[RCOMP]);
+               dstRow[col * 3 + 1] = CHAN_TO_UBYTE(src[GCOMP]);
+               dstRow[col * 3 + 2] = CHAN_TO_UBYTE(src[BCOMP]);
+               src += 3;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_argb4444(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_ARGB4444 ||
+          dstFormat == MESA_FORMAT_ARGB4444_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_ARGB4444 &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_BGRA &&
+       srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            if (dstFormat == MESA_FORMAT_ARGB4444) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_4444( CHAN_TO_UBYTE(src[ACOMP]),
+                                                CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_4444_REV( CHAN_TO_UBYTE(src[ACOMP]),
+                                                    CHAN_TO_UBYTE(src[RCOMP]),
+                                                    CHAN_TO_UBYTE(src[GCOMP]),
+                                                    CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+static GLboolean
+_mesa_texstore_rgba5551(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA5551);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_RGBA5551 &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_RGBA &&
+       srcType == GL_UNSIGNED_SHORT_5_5_5_1) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src =tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+	    for (col = 0; col < srcWidth; col++) {
+	       dstUS[col] = PACK_COLOR_5551( CHAN_TO_UBYTE(src[RCOMP]),
+					     CHAN_TO_UBYTE(src[GCOMP]),
+					     CHAN_TO_UBYTE(src[BCOMP]),
+					     CHAN_TO_UBYTE(src[ACOMP]) );
+	      src += 4;
+	    }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+static GLboolean
+_mesa_texstore_argb1555(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_ARGB1555 ||
+          dstFormat == MESA_FORMAT_ARGB1555_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_ARGB1555 &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_BGRA &&
+       srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src =tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            if (dstFormat == MESA_FORMAT_ARGB1555) {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_1555( CHAN_TO_UBYTE(src[ACOMP]),
+                                                CHAN_TO_UBYTE(src[RCOMP]),
+                                                CHAN_TO_UBYTE(src[GCOMP]),
+                                                CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dstUS[col] = PACK_COLOR_1555_REV( CHAN_TO_UBYTE(src[ACOMP]),
+                                                    CHAN_TO_UBYTE(src[RCOMP]),
+                                                    CHAN_TO_UBYTE(src[GCOMP]),
+                                                    CHAN_TO_UBYTE(src[BCOMP]) );
+                  src += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_argb2101010(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_ARGB2101010);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_ARGB2101010 &&
+       srcFormat == GL_BGRA &&
+       srcType == GL_UNSIGNED_INT_2_10_10_10_REV &&
+       baseInternalFormat == GL_RGBA) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         if (baseInternalFormat == GL_RGBA) {
+            for (row = 0; row < srcHeight; row++) {
+               GLuint *dstUI = (GLuint *) dstRow;
+               for (col = 0; col < srcWidth; col++) {
+                  GLushort a,r,g,b;
+
+                  UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
+                  dstUI[col] = PACK_COLOR_2101010_US(a, r, g, b);
+                  src += 4;
+               }
+               dstRow += dstRowStride;
+            }
+         } else if (baseInternalFormat == GL_RGB) {
+            for (row = 0; row < srcHeight; row++) {
+               GLuint *dstUI = (GLuint *) dstRow;
+               for (col = 0; col < srcWidth; col++) {
+                  GLushort r,g,b;
+
+                  UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
+                  UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
+                  dstUI[col] = PACK_COLOR_2101010_US(0xffff, r, g, b);
+                  src += 4;
+               }
+               dstRow += dstRowStride;
+            }
+         } else {
+            ASSERT(0);
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Do texstore for 2-channel, 4-bit/channel, unsigned normalized formats.
+ */
+static GLboolean
+_mesa_texstore_unorm44(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_AL44);
+   ASSERT(texelBytes == 1);
+
+   {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLubyte *dstUS = (GLubyte *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               /* src[0] is luminance, src[1] is alpha */
+               dstUS[col] = PACK_COLOR_44( CHAN_TO_UBYTE(src[1]),
+                                           CHAN_TO_UBYTE(src[0]) );
+               src += 2;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Do texstore for 2-channel, 8-bit/channel, unsigned normalized formats.
+ */
+static GLboolean
+_mesa_texstore_unorm88(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_AL88 ||
+          dstFormat == MESA_FORMAT_AL88_REV ||
+          dstFormat == MESA_FORMAT_RG88 ||
+          dstFormat == MESA_FORMAT_RG88_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       ((dstFormat == MESA_FORMAT_AL88 &&
+         baseInternalFormat == GL_LUMINANCE_ALPHA &&
+         srcFormat == GL_LUMINANCE_ALPHA) ||
+        (dstFormat == MESA_FORMAT_RG88 &&
+         baseInternalFormat == srcFormat)) &&
+       srcType == GL_UNSIGNED_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+	    littleEndian &&
+	    srcType == GL_UNSIGNED_BYTE &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if (dstFormat == MESA_FORMAT_AL88 || dstFormat == MESA_FORMAT_AL88_REV) {
+	 if ((littleEndian && dstFormat == MESA_FORMAT_AL88) ||
+	     (!littleEndian && dstFormat == MESA_FORMAT_AL88_REV)) {
+	    dstmap[0] = 0;
+	    dstmap[1] = 3;
+	 }
+	 else {
+	    dstmap[0] = 3;
+	    dstmap[1] = 0;
+	 }
+      }
+      else {
+	 if ((littleEndian && dstFormat == MESA_FORMAT_RG88) ||
+	     (!littleEndian && dstFormat == MESA_FORMAT_RG88_REV)) {
+	    dstmap[0] = 0;
+	    dstmap[1] = 1;
+	 }
+	 else {
+	    dstmap[0] = 1;
+	    dstmap[1] = 0;
+	 }
+      }
+      dstmap[2] = ZERO;		/* ? */
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 2,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            if (dstFormat == MESA_FORMAT_AL88 ||
+		dstFormat == MESA_FORMAT_RG88) {
+               for (col = 0; col < srcWidth; col++) {
+                  /* src[0] is luminance, src[1] is alpha */
+                 dstUS[col] = PACK_COLOR_88( CHAN_TO_UBYTE(src[1]),
+                                             CHAN_TO_UBYTE(src[0]) );
+                 src += 2;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  /* src[0] is luminance, src[1] is alpha */
+                 dstUS[col] = PACK_COLOR_88_REV( CHAN_TO_UBYTE(src[1]),
+                                                 CHAN_TO_UBYTE(src[0]) );
+                 src += 2;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Do texstore for 2-channel, 16-bit/channel, unsigned normalized formats.
+ */
+static GLboolean
+_mesa_texstore_unorm1616(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_AL1616 ||
+          dstFormat == MESA_FORMAT_AL1616_REV ||
+	  dstFormat == MESA_FORMAT_RG1616 ||
+          dstFormat == MESA_FORMAT_RG1616_REV);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       ((dstFormat == MESA_FORMAT_AL1616 &&
+         baseInternalFormat == GL_LUMINANCE_ALPHA &&
+         srcFormat == GL_LUMINANCE_ALPHA) ||
+        (dstFormat == MESA_FORMAT_RG1616 &&
+         baseInternalFormat == srcFormat)) &&
+       srcType == GL_UNSIGNED_SHORT &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint *) dstRow;
+            if (dstFormat == MESA_FORMAT_AL1616 ||
+		dstFormat == MESA_FORMAT_RG1616) {
+               for (col = 0; col < srcWidth; col++) {
+		  GLushort l, a;
+
+		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
+		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
+		  dstUI[col] = PACK_COLOR_1616(a, l);
+		  src += 2;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+		  GLushort l, a;
+
+		  UNCLAMPED_FLOAT_TO_USHORT(l, src[0]);
+		  UNCLAMPED_FLOAT_TO_USHORT(a, src[1]);
+		  dstUI[col] = PACK_COLOR_1616_REV(a, l);
+		  src += 2;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* Texstore for R16, A16, L16, I16. */
+static GLboolean
+_mesa_texstore_unorm16(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_R16 ||
+          dstFormat == MESA_FORMAT_A16 ||
+          dstFormat == MESA_FORMAT_L16 ||
+          dstFormat == MESA_FORMAT_I16);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_SHORT &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+	    for (col = 0; col < srcWidth; col++) {
+	       GLushort r;
+
+	       UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);
+	       dstUS[col] = r;
+	       src += 1;
+	    }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_rgba_16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_16);
+   ASSERT(texelBytes == 8);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGBA &&
+       srcFormat == GL_RGBA &&
+       srcType == GL_UNSIGNED_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstUS = (GLushort *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               GLushort r, g, b, a;
+
+               UNCLAMPED_FLOAT_TO_USHORT(r, src[0]);
+               UNCLAMPED_FLOAT_TO_USHORT(g, src[1]);
+               UNCLAMPED_FLOAT_TO_USHORT(b, src[2]);
+               UNCLAMPED_FLOAT_TO_USHORT(a, src[3]);
+               dstUS[col*4+0] = r;
+               dstUS[col*4+1] = g;
+               dstUS[col*4+2] = b;
+               dstUS[col*4+3] = a;
+               src += 4;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_signed_rgba_16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGB_16 ||
+          dstFormat == MESA_FORMAT_SIGNED_RGBA_16);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGBA &&
+       dstFormat == MESA_FORMAT_SIGNED_RGBA_16 &&
+       srcFormat == GL_RGBA &&
+       srcType == GL_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      const GLuint comps = _mesa_get_format_bytes(dstFormat) / 2;
+      GLint img, row, col;
+
+      if (!tempImage)
+         return GL_FALSE;
+
+      /* Note: tempImage is always float[4] / RGBA.  We convert to 1, 2,
+       * 3 or 4 components/pixel here.
+       */
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLshort *dstRowS = (GLshort *) dstRow;
+            if (dstFormat == MESA_FORMAT_SIGNED_RGBA_16) {
+               for (col = 0; col < srcWidth; col++) {
+                  GLuint c;
+                  for (c = 0; c < comps; c++) {
+                     GLshort p;
+                     UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 4 + c]);
+                     dstRowS[col * comps + c] = p;
+                  }
+               }
+               dstRow += dstRowStride;
+               src += 4 * srcWidth;
+            } else {
+               for (col = 0; col < srcWidth; col++) {
+                  GLuint c;
+                  for (c = 0; c < comps; c++) {
+                     GLshort p;
+                     UNCLAMPED_FLOAT_TO_SHORT(p, src[col * 3 + c]);
+                     dstRowS[col * comps + c] = p;
+                  }
+               }
+               dstRow += dstRowStride;
+               src += 3 * srcWidth;
+            }
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+static GLboolean
+_mesa_texstore_rgb332(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGB332);
+   ASSERT(texelBytes == 1);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == GL_RGB &&
+       srcFormat == GL_RGB && srcType == GL_UNSIGNED_BYTE_3_3_2) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col] = PACK_COLOR_332( CHAN_TO_UBYTE(src[RCOMP]),
+                                             CHAN_TO_UBYTE(src[GCOMP]),
+                                             CHAN_TO_UBYTE(src[BCOMP]) );
+               src += 3;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Texstore for _mesa_texformat_a8, _mesa_texformat_l8, _mesa_texformat_i8.
+ */
+static GLboolean
+_mesa_texstore_unorm8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_A8 ||
+          dstFormat == MESA_FORMAT_L8 ||
+          dstFormat == MESA_FORMAT_I8 ||
+          dstFormat == MESA_FORMAT_R8);
+   ASSERT(texelBytes == 1);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+	    srcType == GL_UNSIGNED_BYTE &&
+	    can_swizzle(baseInternalFormat) &&
+	    can_swizzle(srcFormat)) {
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if (dstFormat == MESA_FORMAT_A8) {
+	 dstmap[0] = 3;
+      }
+      else {
+	 dstmap[0] = 0;
+      }
+      dstmap[1] = ZERO;		/* ? */
+      dstmap[2] = ZERO;		/* ? */
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				srcFormat,
+				srcType,
+				baseInternalFormat,
+				dstmap, 1,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path */
+      const GLchan *tempImage = _mesa_make_temp_chan_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking);
+      const GLchan *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col] = CHAN_TO_UBYTE(src[col]);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+static GLboolean
+_mesa_texstore_ci8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+
+   (void) dims; (void) baseInternalFormat;
+   ASSERT(dstFormat == MESA_FORMAT_CI8);
+   ASSERT(texelBytes == 1);
+   ASSERT(baseInternalFormat == GL_COLOR_INDEX);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       srcFormat == GL_COLOR_INDEX &&
+       srcType == GL_UNSIGNED_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            const GLvoid *src = _mesa_image_address(dims, srcPacking,
+                srcAddr, srcWidth, srcHeight, srcFormat, srcType, img, row, 0);
+            _mesa_unpack_index_span(ctx, srcWidth, GL_UNSIGNED_BYTE, dstRow,
+                                    srcType, src, srcPacking,
+                                    ctx->_ImageTransferState);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Texstore for _mesa_texformat_ycbcr or _mesa_texformat_ycbcr_REV.
+ */
+static GLboolean
+_mesa_texstore_ycbcr(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+
+   (void) ctx; (void) dims; (void) baseInternalFormat;
+
+   ASSERT((dstFormat == MESA_FORMAT_YCBCR) ||
+          (dstFormat == MESA_FORMAT_YCBCR_REV));
+   ASSERT(texelBytes == 2);
+   ASSERT(ctx->Extensions.MESA_ycbcr_texture);
+   ASSERT(srcFormat == GL_YCBCR_MESA);
+   ASSERT((srcType == GL_UNSIGNED_SHORT_8_8_MESA) ||
+          (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA));
+   ASSERT(baseInternalFormat == GL_YCBCR_MESA);
+
+   /* always just memcpy since no pixel transfer ops apply */
+   memcpy_texture(ctx, dims,
+                  dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                  dstRowStride,
+                  dstImageOffsets,
+                  srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                  srcAddr, srcPacking);
+
+   /* Check if we need byte swapping */
+   /* XXX the logic here _might_ be wrong */
+   if (srcPacking->SwapBytes ^
+       (srcType == GL_UNSIGNED_SHORT_8_8_REV_MESA) ^
+       (dstFormat == MESA_FORMAT_YCBCR_REV) ^
+       !littleEndian) {
+      GLint img, row;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            _mesa_swap2((GLushort *) dstRow, srcWidth);
+            dstRow += dstRowStride;
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+static GLboolean
+_mesa_texstore_dudv8(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_DUDV8);
+   ASSERT(texelBytes == 2);
+   ASSERT(ctx->Extensions.ATI_envmap_bumpmap);
+   ASSERT((srcFormat == GL_DU8DV8_ATI) ||
+	  (srcFormat == GL_DUDV_ATI));
+   ASSERT(baseInternalFormat == GL_DUDV_ATI);
+
+   if (!srcPacking->SwapBytes && srcType == GL_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (srcType == GL_BYTE) {
+      GLubyte dstmap[4];
+
+      /* dstmap - how to swizzle from RGBA to dst format:
+       */
+      if (littleEndian) {
+	 dstmap[0] = 0;
+	 dstmap[1] = 3;
+      }
+      else {
+	 dstmap[0] = 3;
+	 dstmap[1] = 0;
+      }
+      dstmap[2] = ZERO;		/* ? */
+      dstmap[3] = ONE;		/* ? */
+      
+      _mesa_swizzle_ubyte_image(ctx, dims,
+				GL_LUMINANCE_ALPHA, /* hack */
+				GL_UNSIGNED_BYTE, /* hack */
+				GL_LUMINANCE_ALPHA, /* hack */
+				dstmap, 2,
+				dstAddr, dstXoffset, dstYoffset, dstZoffset,
+				dstRowStride, dstImageOffsets,
+				srcWidth, srcHeight, srcDepth, srcAddr,
+				srcPacking);      
+   }   
+   else {
+      /* general path - note this is defined for 2d textures only */
+      const GLint components = _mesa_components_in_format(baseInternalFormat);
+      const GLint srcStride = _mesa_image_row_stride(srcPacking, srcWidth,
+                                                     srcFormat, srcType);
+      GLbyte *tempImage, *dst, *src;
+      GLint row;
+
+      tempImage = (GLbyte *) malloc(srcWidth * srcHeight * srcDepth
+                                          * components * sizeof(GLbyte));
+      if (!tempImage)
+         return GL_FALSE;
+
+      src = (GLbyte *) _mesa_image_address(dims, srcPacking, srcAddr,
+                                           srcWidth, srcHeight,
+                                           srcFormat, srcType,
+                                           0, 0, 0);
+
+      dst = tempImage;
+      for (row = 0; row < srcHeight; row++) {
+         _mesa_unpack_dudv_span_byte(ctx, srcWidth, baseInternalFormat,
+                                     dst, srcFormat, srcType, src,
+                                     srcPacking, 0);
+         dst += srcWidth * components;
+         src += srcStride;
+      }
+ 
+      src = tempImage;
+      dst = (GLbyte *) dstAddr
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+      for (row = 0; row < srcHeight; row++) {
+         memcpy(dst, src, srcWidth * texelBytes);
+         dst += dstRowStride;
+         src += srcWidth * texelBytes;
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a texture in a signed normalized 8-bit format.
+ */
+static GLboolean
+_mesa_texstore_snorm8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_A8 ||
+          dstFormat == MESA_FORMAT_SIGNED_L8 ||
+          dstFormat == MESA_FORMAT_SIGNED_I8 ||
+          dstFormat == MESA_FORMAT_SIGNED_R8);
+   ASSERT(texelBytes == 1);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLbyte *dstRow = (GLbyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            for (col = 0; col < srcWidth; col++) {
+               dstRow[col] = FLOAT_TO_BYTE_TEX(src[col]);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a texture in a signed normalized two-channel 16-bit format.
+ */
+static GLboolean
+_mesa_texstore_snorm88(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL88 ||
+          dstFormat == MESA_FORMAT_SIGNED_RG88_REV);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_BYTE &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLbyte *dstRow = (GLbyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLbyte *dst = dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               dst[0] = FLOAT_TO_BYTE_TEX(src[0]);
+               dst[1] = FLOAT_TO_BYTE_TEX(src[1]);
+               src += 2;
+               dst += 2;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+/* Texstore for signed R16, A16, L16, I16. */
+static GLboolean
+_mesa_texstore_snorm16(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_R16 ||
+          dstFormat == MESA_FORMAT_SIGNED_A16 ||
+          dstFormat == MESA_FORMAT_SIGNED_L16 ||
+          dstFormat == MESA_FORMAT_SIGNED_I16);
+   ASSERT(texelBytes == 2);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_SHORT &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLshort *dstUS = (GLshort *) dstRow;
+	    for (col = 0; col < srcWidth; col++) {
+	       GLushort r;
+
+	       UNCLAMPED_FLOAT_TO_SHORT(r, src[0]);
+	       dstUS[col] = r;
+	       src += 1;
+	    }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+/**
+ * Do texstore for 2-channel, 16-bit/channel, signed normalized formats.
+ */
+static GLboolean
+_mesa_texstore_snorm1616(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_AL1616 ||
+          dstFormat == MESA_FORMAT_SIGNED_GR1616);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_SHORT &&
+       littleEndian) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLshort *dst = (GLshort *) dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               GLushort l, a;
+
+               UNCLAMPED_FLOAT_TO_SHORT(l, src[0]);
+               UNCLAMPED_FLOAT_TO_SHORT(a, src[1]);
+               dst[0] = l;
+               dst[1] = a;
+               src += 2;
+               dst += 2;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+/**
+ * Store a texture in MESA_FORMAT_SIGNED_RGBX8888.
+ */
+static GLboolean
+_mesa_texstore_signed_rgbx8888(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBX8888);
+   ASSERT(texelBytes == 4);
+
+   {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *srcRow = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLbyte *dstRow = (GLbyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLbyte *dst = dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               dst[3] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
+               dst[2] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
+               dst[1] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
+               dst[0] = 127;
+               srcRow += 3;
+               dst += 4;
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+/**
+ * Store a texture in MESA_FORMAT_SIGNED_RGBA8888 or
+ * MESA_FORMAT_SIGNED_RGBA8888_REV
+ */
+static GLboolean
+_mesa_texstore_signed_rgba8888(TEXSTORE_PARAMS)
+{
+   const GLboolean littleEndian = _mesa_little_endian();
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_SIGNED_RGBA8888 ||
+          dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV);
+   ASSERT(texelBytes == 4);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_SIGNED_RGBA8888 &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_BYTE && !littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && littleEndian))) {
+       /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       dstFormat == MESA_FORMAT_SIGNED_RGBA8888_REV &&
+       baseInternalFormat == GL_RGBA &&
+      ((srcFormat == GL_RGBA && srcType == GL_BYTE && littleEndian) ||
+       (srcFormat == GL_ABGR_EXT && srcType == GL_BYTE && !littleEndian))) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *srcRow = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLbyte *dstRow = (GLbyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLbyte *dst = dstRow;
+            if (dstFormat == MESA_FORMAT_SIGNED_RGBA8888) {
+               for (col = 0; col < srcWidth; col++) {
+                  dst[3] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
+                  dst[2] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
+                  dst[1] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
+                  dst[0] = FLOAT_TO_BYTE_TEX(srcRow[ACOMP]);
+                  srcRow += 4;
+                  dst += 4;
+               }
+            }
+            else {
+               for (col = 0; col < srcWidth; col++) {
+                  dst[0] = FLOAT_TO_BYTE_TEX(srcRow[RCOMP]);
+                  dst[1] = FLOAT_TO_BYTE_TEX(srcRow[GCOMP]);
+                  dst[2] = FLOAT_TO_BYTE_TEX(srcRow[BCOMP]);
+                  dst[3] = FLOAT_TO_BYTE_TEX(srcRow[ACOMP]);
+                  srcRow += 4;
+                  dst += 4;
+               }
+            }
+            dstRow += dstRowStride;
+         }
+      }
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a combined depth/stencil texture image.
+ */
+static GLboolean
+_mesa_texstore_z24_s8(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffff;
+   const GLint srcRowStride
+      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
+      / sizeof(GLuint);
+   GLint img, row;
+
+   ASSERT(dstFormat == MESA_FORMAT_Z24_S8);
+   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||
+          srcFormat == GL_DEPTH_COMPONENT ||
+          srcFormat == GL_STENCIL_INDEX);
+   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT || srcType == GL_UNSIGNED_INT_24_8_EXT);
+
+   if (srcFormat == GL_DEPTH_STENCIL && ctx->Pixel.DepthScale == 1.0f &&
+       ctx->Pixel.DepthBias == 0.0f &&
+       !srcPacking->SwapBytes) {
+      /* simple path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else if (srcFormat == GL_DEPTH_COMPONENT ||
+            srcFormat == GL_STENCIL_INDEX) {
+      /* In case we only upload depth we need to preserve the stencil */
+      for (img = 0; img < srcDepth; img++) {
+	 GLuint *dstRow = (GLuint *) dstAddr
+            + dstImageOffsets[dstZoffset + img]
+            + dstYoffset * dstRowStride / sizeof(GLuint)
+            + dstXoffset;
+         const GLuint *src
+            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
+                  srcWidth, srcHeight,
+                  srcFormat, srcType,
+                  img, 0, 0);
+         for (row = 0; row < srcHeight; row++) {
+            GLuint depth[MAX_WIDTH];
+	    GLubyte stencil[MAX_WIDTH];
+            GLint i;
+	    GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
+
+	    if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
+	       keepstencil = GL_TRUE;
+	    }
+            else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
+	       keepdepth = GL_TRUE;
+	    }
+
+	    if (keepdepth == GL_FALSE)
+	       /* the 24 depth bits will be in the low position: */
+	       _mesa_unpack_depth_span(ctx, srcWidth,
+				       GL_UNSIGNED_INT, /* dst type */
+				       keepstencil ? depth : dstRow, /* dst addr */
+				       depthScale,
+				       srcType, src, srcPacking);
+
+	    if (keepstencil == GL_FALSE)
+	       /* get the 8-bit stencil values */
+	       _mesa_unpack_stencil_span(ctx, srcWidth,
+					 GL_UNSIGNED_BYTE, /* dst type */
+					 stencil, /* dst addr */
+					 srcType, src, srcPacking,
+					 ctx->_ImageTransferState);
+
+	    for (i = 0; i < srcWidth; i++) {
+	       if (keepstencil)
+		  dstRow[i] = depth[i] << 8 | (dstRow[i] & 0x000000FF);
+	       else
+		  dstRow[i] = (dstRow[i] & 0xFFFFFF00) | (stencil[i] & 0xFF);
+	    }
+
+            src += srcRowStride;
+            dstRow += dstRowStride / sizeof(GLuint);
+         }
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store a combined depth/stencil texture image.
+ */
+static GLboolean
+_mesa_texstore_s8_z24(TEXSTORE_PARAMS)
+{
+   const GLuint depthScale = 0xffffff;
+   const GLint srcRowStride
+      = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
+      / sizeof(GLuint);
+   GLint img, row;
+
+   ASSERT(dstFormat == MESA_FORMAT_S8_Z24);
+   ASSERT(srcFormat == GL_DEPTH_STENCIL_EXT ||
+          srcFormat == GL_DEPTH_COMPONENT ||
+          srcFormat == GL_STENCIL_INDEX);
+   ASSERT(srcFormat != GL_DEPTH_STENCIL_EXT ||
+          srcType == GL_UNSIGNED_INT_24_8_EXT);
+
+   for (img = 0; img < srcDepth; img++) {
+      GLuint *dstRow = (GLuint *) dstAddr
+	 + dstImageOffsets[dstZoffset + img]
+	 + dstYoffset * dstRowStride / sizeof(GLuint)
+	 + dstXoffset;
+      const GLuint *src
+	 = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
+						srcWidth, srcHeight,
+						srcFormat, srcType,
+						img, 0, 0);
+      for (row = 0; row < srcHeight; row++) {
+	 GLuint depth[MAX_WIDTH];
+	 GLubyte stencil[MAX_WIDTH];
+	 GLint i;
+	 GLboolean keepdepth = GL_FALSE, keepstencil = GL_FALSE;
+	 
+	 if (srcFormat == GL_DEPTH_COMPONENT) { /* preserve stencil */
+	    keepstencil = GL_TRUE;
+	 }
+         else if (srcFormat == GL_STENCIL_INDEX) { /* preserve depth */
+	    keepdepth = GL_TRUE;
+	 }
+
+	 if (keepdepth == GL_FALSE)
+	    /* the 24 depth bits will be in the low position: */
+	    _mesa_unpack_depth_span(ctx, srcWidth,
+				    GL_UNSIGNED_INT, /* dst type */
+				    keepstencil ? depth : dstRow, /* dst addr */
+				    depthScale,
+				    srcType, src, srcPacking);	 
+
+	 if (keepstencil == GL_FALSE)
+	    /* get the 8-bit stencil values */
+	    _mesa_unpack_stencil_span(ctx, srcWidth,
+				      GL_UNSIGNED_BYTE, /* dst type */
+				      stencil, /* dst addr */
+				      srcType, src, srcPacking,
+				      ctx->_ImageTransferState);
+
+	 /* merge stencil values into depth values */
+	 for (i = 0; i < srcWidth; i++) {
+	    if (keepstencil)
+	       dstRow[i] = depth[i] | (dstRow[i] & 0xFF000000);
+	    else
+	       dstRow[i] = (dstRow[i] & 0xFFFFFF) | (stencil[i] << 24);
+
+	 }
+	 src += srcRowStride;
+	 dstRow += dstRowStride / sizeof(GLuint);
+      }
+   }
+   return GL_TRUE;
+}
+
+
+/**
+ * Store simple 8-bit/value stencil texture data.
+ */
+static GLboolean
+_mesa_texstore_s8(TEXSTORE_PARAMS)
+{
+   ASSERT(dstFormat == MESA_FORMAT_S8);
+   ASSERT(srcFormat == GL_STENCIL_INDEX);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      const GLint srcRowStride
+	 = _mesa_image_row_stride(srcPacking, srcWidth, srcFormat, srcType)
+	 / sizeof(GLuint);
+      GLint img, row;
+      
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img]
+            + dstYoffset * dstRowStride / sizeof(GLuint)
+            + dstXoffset;
+         const GLuint *src
+            = (const GLuint *) _mesa_image_address(dims, srcPacking, srcAddr,
+                                                   srcWidth, srcHeight,
+                                                   srcFormat, srcType,
+                                                   img, 0, 0);
+         for (row = 0; row < srcHeight; row++) {
+            GLubyte stencil[MAX_WIDTH];
+            GLint i;
+
+            /* get the 8-bit stencil values */
+            _mesa_unpack_stencil_span(ctx, srcWidth,
+                                      GL_UNSIGNED_BYTE, /* dst type */
+                                      stencil, /* dst addr */
+                                      srcType, src, srcPacking,
+                                      ctx->_ImageTransferState);
+            /* merge stencil values into depth values */
+            for (i = 0; i < srcWidth; i++)
+               dstRow[i] = stencil[i];
+
+            src += srcRowStride;
+            dstRow += dstRowStride / sizeof(GLubyte);
+         }
+      }
+
+   }
+
+   return GL_TRUE;
+}
+
+
+/**
+ * Store an image in any of the formats:
+ *   _mesa_texformat_rgba_float32
+ *   _mesa_texformat_rgb_float32
+ *   _mesa_texformat_alpha_float32
+ *   _mesa_texformat_luminance_float32
+ *   _mesa_texformat_luminance_alpha_float32
+ *   _mesa_texformat_intensity_float32
+ */
+static GLboolean
+_mesa_texstore_rgba_float32(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT32 ||
+          dstFormat == MESA_FORMAT_RGB_FLOAT32 ||
+          dstFormat == MESA_FORMAT_ALPHA_FLOAT32 ||
+          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT32 ||
+          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 ||
+          dstFormat == MESA_FORMAT_INTENSITY_FLOAT32 ||
+          dstFormat == MESA_FORMAT_R_FLOAT32 ||
+          dstFormat == MESA_FORMAT_RG_FLOAT32);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY ||
+          baseInternalFormat == GL_RED ||
+          baseInternalFormat == GL_RG);
+   ASSERT(texelBytes == components * sizeof(GLfloat));
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       baseInternalFormat == baseFormat &&
+       srcType == GL_FLOAT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *srcRow = tempImage;
+      GLint bytesPerRow;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      bytesPerRow = srcWidth * components * sizeof(GLfloat);
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            memcpy(dstRow, srcRow, bytesPerRow);
+            dstRow += dstRowStride;
+            srcRow += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+/**
+ * As above, but store 16-bit floats.
+ */
+static GLboolean
+_mesa_texstore_rgba_float16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_FLOAT16 ||
+          dstFormat == MESA_FORMAT_RGB_FLOAT16 ||
+          dstFormat == MESA_FORMAT_ALPHA_FLOAT16 ||
+          dstFormat == MESA_FORMAT_LUMINANCE_FLOAT16 ||
+          dstFormat == MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 ||
+          dstFormat == MESA_FORMAT_INTENSITY_FLOAT16 ||
+          dstFormat == MESA_FORMAT_R_FLOAT16 ||
+          dstFormat == MESA_FORMAT_RG_FLOAT16);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY ||
+          baseInternalFormat == GL_RED ||
+          baseInternalFormat == GL_RG);
+   ASSERT(texelBytes == components * sizeof(GLhalfARB));
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       baseInternalFormat == baseFormat &&
+       srcType == GL_HALF_FLOAT_ARB) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLhalfARB *dstTexel = (GLhalfARB *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = _mesa_float_to_half(src[i]);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, signed int8 */
+static GLboolean
+_mesa_texstore_rgba_int8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT8);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLbyte));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking, 0x0);
+      const GLfloat *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLbyte *dstTexel = (GLbyte *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLbyte) src[i];
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, signed int16 */
+static GLboolean
+_mesa_texstore_rgba_int16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT16);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLshort));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking, 0x0);
+      const GLfloat *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLshort *dstTexel = (GLshort *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLint) src[i];
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, signed int32 */
+static GLboolean
+_mesa_texstore_rgba_int32(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_INT32);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLint));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_INT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking, 0x0);
+      const GLfloat *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLint *dstTexel = (GLint *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLint) src[i];
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, unsigned int8 */
+static GLboolean
+_mesa_texstore_rgba_uint8(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT8);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLubyte));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_BYTE) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLuint *tempImage =
+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
+                              srcWidth, srcHeight, srcDepth,
+                              srcFormat, srcType, srcAddr, srcPacking);
+      const GLuint *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLubyte *dstTexel = (GLubyte *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLubyte) CLAMP(src[i], 0, 0xff);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, unsigned int16 */
+static GLboolean
+_mesa_texstore_rgba_uint16(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT16);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLushort));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_SHORT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLuint *tempImage =
+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
+                              srcWidth, srcHeight, srcDepth,
+                              srcFormat, srcType, srcAddr, srcPacking);
+      const GLuint *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLushort *dstTexel = (GLushort *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = (GLushort) CLAMP(src[i], 0, 0xffff);
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+/* non-normalized, unsigned int32 */
+static GLboolean
+_mesa_texstore_rgba_uint32(TEXSTORE_PARAMS)
+{
+   const GLuint texelBytes = _mesa_get_format_bytes(dstFormat);
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+   const GLint components = _mesa_components_in_format(baseFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGBA_UINT32);
+   ASSERT(baseInternalFormat == GL_RGBA ||
+          baseInternalFormat == GL_RGB ||
+          baseInternalFormat == GL_ALPHA ||
+          baseInternalFormat == GL_LUMINANCE ||
+          baseInternalFormat == GL_LUMINANCE_ALPHA ||
+          baseInternalFormat == GL_INTENSITY);
+   ASSERT(texelBytes == components * sizeof(GLuint));
+
+   /* Note: Pixel transfer ops (scale, bias, table lookup) do not apply
+    * to integer formats.
+    */
+   if (!srcPacking->SwapBytes &&
+       baseInternalFormat == srcFormat &&
+       srcType == GL_UNSIGNED_INT) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLuint *tempImage =
+         make_temp_uint_image(ctx, dims, baseInternalFormat, baseFormat,
+                              srcWidth, srcHeight, srcDepth,
+                              srcFormat, srcType, srcAddr, srcPacking);
+      const GLuint *src = tempImage;
+      GLint img, row;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * texelBytes
+            + dstYoffset * dstRowStride
+            + dstXoffset * texelBytes;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstTexel = (GLuint *) dstRow;
+            GLint i;
+            for (i = 0; i < srcWidth * components; i++) {
+               dstTexel[i] = src[i];
+            }
+            dstRow += dstRowStride;
+            src += srcWidth * components;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+
+#if FEATURE_EXT_texture_sRGB
+static GLboolean
+_mesa_texstore_srgb8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SRGB8);
+
+   /* reuse normal rgb texstore code */
+   newDstFormat = MESA_FORMAT_RGB888;
+
+   k = _mesa_texstore_rgb888(ctx, dims, baseInternalFormat,
+                             newDstFormat, dstAddr,
+                             dstXoffset, dstYoffset, dstZoffset,
+                             dstRowStride, dstImageOffsets,
+                             srcWidth, srcHeight, srcDepth,
+                             srcFormat, srcType,
+                             srcAddr, srcPacking);
+   return k;
+}
+
+
+static GLboolean
+_mesa_texstore_srgba8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SRGBA8);
+
+   /* reuse normal rgba texstore code */
+   newDstFormat = MESA_FORMAT_RGBA8888;
+   k = _mesa_texstore_rgba8888(ctx, dims, baseInternalFormat,
+                               newDstFormat, dstAddr,
+                               dstXoffset, dstYoffset, dstZoffset,
+                               dstRowStride, dstImageOffsets,
+                               srcWidth, srcHeight, srcDepth,
+                               srcFormat, srcType,
+                               srcAddr, srcPacking);
+   return k;
+}
+
+
+static GLboolean
+_mesa_texstore_sargb8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SARGB8);
+
+   /* reuse normal rgba texstore code */
+   newDstFormat = MESA_FORMAT_ARGB8888;
+
+   k = _mesa_texstore_argb8888(ctx, dims, baseInternalFormat,
+                               newDstFormat, dstAddr,
+                               dstXoffset, dstYoffset, dstZoffset,
+                               dstRowStride, dstImageOffsets,
+                               srcWidth, srcHeight, srcDepth,
+                               srcFormat, srcType,
+                               srcAddr, srcPacking);
+   return k;
+}
+
+
+static GLboolean
+_mesa_texstore_sl8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SL8);
+
+   newDstFormat = MESA_FORMAT_L8;
+
+   /* _mesa_textore_a8 handles luminance8 too */
+   k = _mesa_texstore_unorm8(ctx, dims, baseInternalFormat,
+                         newDstFormat, dstAddr,
+                         dstXoffset, dstYoffset, dstZoffset,
+                         dstRowStride, dstImageOffsets,
+                         srcWidth, srcHeight, srcDepth,
+                         srcFormat, srcType,
+                         srcAddr, srcPacking);
+   return k;
+}
+
+
+static GLboolean
+_mesa_texstore_sla8(TEXSTORE_PARAMS)
+{
+   gl_format newDstFormat;
+   GLboolean k;
+
+   ASSERT(dstFormat == MESA_FORMAT_SLA8);
+
+   /* reuse normal luminance/alpha texstore code */
+   newDstFormat = MESA_FORMAT_AL88;
+
+   k = _mesa_texstore_unorm88(ctx, dims, baseInternalFormat,
+			      newDstFormat, dstAddr,
+			      dstXoffset, dstYoffset, dstZoffset,
+			      dstRowStride, dstImageOffsets,
+			      srcWidth, srcHeight, srcDepth,
+			      srcFormat, srcType,
+			      srcAddr, srcPacking);
+   return k;
+}
+
+#else
+
+/* these are used only in texstore_funcs[] below */
+#define _mesa_texstore_srgb8 NULL
+#define _mesa_texstore_srgba8 NULL
+#define _mesa_texstore_sargb8 NULL
+#define _mesa_texstore_sl8 NULL
+#define _mesa_texstore_sla8 NULL
+
+#endif /* FEATURE_EXT_texture_sRGB */
+
+static GLboolean
+_mesa_texstore_rgb9_e5(TEXSTORE_PARAMS)
+{
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_RGB9_E5_FLOAT);
+   ASSERT(baseInternalFormat == GL_RGB);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       srcFormat == GL_RGB &&
+       srcType == GL_UNSIGNED_INT_5_9_9_9_REV) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *srcRow = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * 4
+            + dstYoffset * dstRowStride
+            + dstXoffset * 4;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint*)dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               dstUI[col] = float3_to_rgb9e5(&srcRow[col * 3]);
+            }
+            dstRow += dstRowStride;
+            srcRow += srcWidth * 3;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+static GLboolean
+_mesa_texstore_r11_g11_b10f(TEXSTORE_PARAMS)
+{
+   const GLenum baseFormat = _mesa_get_format_base_format(dstFormat);
+
+   ASSERT(dstFormat == MESA_FORMAT_R11_G11_B10_FLOAT);
+   ASSERT(baseInternalFormat == GL_RGB);
+
+   if (!ctx->_ImageTransferState &&
+       !srcPacking->SwapBytes &&
+       srcFormat == GL_RGB &&
+       srcType == GL_UNSIGNED_INT_10F_11F_11F_REV) {
+      /* simple memcpy path */
+      memcpy_texture(ctx, dims,
+                     dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                     dstRowStride,
+                     dstImageOffsets,
+                     srcWidth, srcHeight, srcDepth, srcFormat, srcType,
+                     srcAddr, srcPacking);
+   }
+   else {
+      /* general path */
+      const GLfloat *tempImage = _mesa_make_temp_float_image(ctx, dims,
+                                                 baseInternalFormat,
+                                                 baseFormat,
+                                                 srcWidth, srcHeight, srcDepth,
+                                                 srcFormat, srcType, srcAddr,
+                                                 srcPacking,
+                                                 ctx->_ImageTransferState);
+      const GLfloat *srcRow = tempImage;
+      GLint img, row, col;
+      if (!tempImage)
+         return GL_FALSE;
+      for (img = 0; img < srcDepth; img++) {
+         GLubyte *dstRow = (GLubyte *) dstAddr
+            + dstImageOffsets[dstZoffset + img] * 4
+            + dstYoffset * dstRowStride
+            + dstXoffset * 4;
+         for (row = 0; row < srcHeight; row++) {
+            GLuint *dstUI = (GLuint*)dstRow;
+            for (col = 0; col < srcWidth; col++) {
+               dstUI[col] = float3_to_r11g11b10f(&srcRow[col * 3]);
+            }
+            dstRow += dstRowStride;
+            srcRow += srcWidth * 3;
+         }
+      }
+
+      free((void *) tempImage);
+   }
+   return GL_TRUE;
+}
+
+
+
+/**
+ * Table mapping MESA_FORMAT_* to _mesa_texstore_*()
+ * XXX this is somewhat temporary.
+ */
+static const struct {
+   gl_format Name;
+   StoreTexImageFunc Store;
+}
+texstore_funcs[MESA_FORMAT_COUNT] =
+{
+   { MESA_FORMAT_NONE, NULL },
+   { MESA_FORMAT_RGBA8888, _mesa_texstore_rgba8888 },
+   { MESA_FORMAT_RGBA8888_REV, _mesa_texstore_rgba8888 },
+   { MESA_FORMAT_ARGB8888, _mesa_texstore_argb8888 },
+   { MESA_FORMAT_ARGB8888_REV, _mesa_texstore_argb8888 },
+   { MESA_FORMAT_XRGB8888, _mesa_texstore_argb8888 },
+   { MESA_FORMAT_XRGB8888_REV, _mesa_texstore_argb8888 },
+   { MESA_FORMAT_RGB888, _mesa_texstore_rgb888 },
+   { MESA_FORMAT_BGR888, _mesa_texstore_bgr888 },
+   { MESA_FORMAT_RGB565, _mesa_texstore_rgb565 },
+   { MESA_FORMAT_RGB565_REV, _mesa_texstore_rgb565 },
+   { MESA_FORMAT_ARGB4444, _mesa_texstore_argb4444 },
+   { MESA_FORMAT_ARGB4444_REV, _mesa_texstore_argb4444 },
+   { MESA_FORMAT_RGBA5551, _mesa_texstore_rgba5551 },
+   { MESA_FORMAT_ARGB1555, _mesa_texstore_argb1555 },
+   { MESA_FORMAT_ARGB1555_REV, _mesa_texstore_argb1555 },
+   { MESA_FORMAT_AL44, _mesa_texstore_unorm44 },
+   { MESA_FORMAT_AL88, _mesa_texstore_unorm88 },
+   { MESA_FORMAT_AL88_REV, _mesa_texstore_unorm88 },
+   { MESA_FORMAT_AL1616, _mesa_texstore_unorm1616 },
+   { MESA_FORMAT_AL1616_REV, _mesa_texstore_unorm1616 },
+   { MESA_FORMAT_RGB332, _mesa_texstore_rgb332 },
+   { MESA_FORMAT_A8, _mesa_texstore_unorm8 },
+   { MESA_FORMAT_A16, _mesa_texstore_unorm16 },
+   { MESA_FORMAT_L8, _mesa_texstore_unorm8 },
+   { MESA_FORMAT_L16, _mesa_texstore_unorm16 },
+   { MESA_FORMAT_I8, _mesa_texstore_unorm8 },
+   { MESA_FORMAT_I16, _mesa_texstore_unorm16 },
+   { MESA_FORMAT_CI8, _mesa_texstore_ci8 },
+   { MESA_FORMAT_YCBCR, _mesa_texstore_ycbcr },
+   { MESA_FORMAT_YCBCR_REV, _mesa_texstore_ycbcr },
+   { MESA_FORMAT_R8, _mesa_texstore_unorm8 },
+   { MESA_FORMAT_RG88, _mesa_texstore_unorm88 },
+   { MESA_FORMAT_RG88_REV, _mesa_texstore_unorm88 },
+   { MESA_FORMAT_R16, _mesa_texstore_unorm16 },
+   { MESA_FORMAT_RG1616, _mesa_texstore_unorm1616 },
+   { MESA_FORMAT_RG1616_REV, _mesa_texstore_unorm1616 },
+   { MESA_FORMAT_ARGB2101010, _mesa_texstore_argb2101010 },
+   { MESA_FORMAT_Z24_S8, _mesa_texstore_z24_s8 },
+   { MESA_FORMAT_S8_Z24, _mesa_texstore_s8_z24 },
+   { MESA_FORMAT_Z16, _mesa_texstore_z16 },
+   { MESA_FORMAT_X8_Z24, _mesa_texstore_x8_z24 },
+   { MESA_FORMAT_Z24_X8, _mesa_texstore_z24_x8 },
+   { MESA_FORMAT_Z32, _mesa_texstore_z32 },
+   { MESA_FORMAT_S8, _mesa_texstore_s8 },
+   { MESA_FORMAT_SRGB8, _mesa_texstore_srgb8 },
+   { MESA_FORMAT_SRGBA8, _mesa_texstore_srgba8 },
+   { MESA_FORMAT_SARGB8, _mesa_texstore_sargb8 },
+   { MESA_FORMAT_SL8, _mesa_texstore_sl8 },
+   { MESA_FORMAT_SLA8, _mesa_texstore_sla8 },
+   { MESA_FORMAT_SRGB_DXT1, _mesa_texstore_rgb_dxt1 },
+   { MESA_FORMAT_SRGBA_DXT1, _mesa_texstore_rgba_dxt1 },
+   { MESA_FORMAT_SRGBA_DXT3, _mesa_texstore_rgba_dxt3 },
+   { MESA_FORMAT_SRGBA_DXT5, _mesa_texstore_rgba_dxt5 },
+   { MESA_FORMAT_RGB_FXT1, _mesa_texstore_rgb_fxt1 },
+   { MESA_FORMAT_RGBA_FXT1, _mesa_texstore_rgba_fxt1 },
+   { MESA_FORMAT_RGB_DXT1, _mesa_texstore_rgb_dxt1 },
+   { MESA_FORMAT_RGBA_DXT1, _mesa_texstore_rgba_dxt1 },
+   { MESA_FORMAT_RGBA_DXT3, _mesa_texstore_rgba_dxt3 },
+   { MESA_FORMAT_RGBA_DXT5, _mesa_texstore_rgba_dxt5 },
+   { MESA_FORMAT_RGBA_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_RGBA_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_RGB_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_RGB_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_LUMINANCE_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_LUMINANCE_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_INTENSITY_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_INTENSITY_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_R_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_R_FLOAT16, _mesa_texstore_rgba_float16 },
+   { MESA_FORMAT_RG_FLOAT32, _mesa_texstore_rgba_float32 },
+   { MESA_FORMAT_RG_FLOAT16, _mesa_texstore_rgba_float16 },
+
+   { MESA_FORMAT_RGBA_INT8, _mesa_texstore_rgba_int8 },
+   { MESA_FORMAT_RGBA_INT16, _mesa_texstore_rgba_int16 },
+   { MESA_FORMAT_RGBA_INT32, _mesa_texstore_rgba_int32 },
+   { MESA_FORMAT_RGBA_UINT8, _mesa_texstore_rgba_uint8 },
+   { MESA_FORMAT_RGBA_UINT16, _mesa_texstore_rgba_uint16 },
+   { MESA_FORMAT_RGBA_UINT32, _mesa_texstore_rgba_uint32 },
+
+   { MESA_FORMAT_DUDV8, _mesa_texstore_dudv8 },
+
+   { MESA_FORMAT_SIGNED_R8, _mesa_texstore_snorm8 },
+   { MESA_FORMAT_SIGNED_RG88_REV, _mesa_texstore_snorm88 },
+   { MESA_FORMAT_SIGNED_RGBX8888, _mesa_texstore_signed_rgbx8888 },
+
+   { MESA_FORMAT_SIGNED_RGBA8888, _mesa_texstore_signed_rgba8888 },
+   { MESA_FORMAT_SIGNED_RGBA8888_REV, _mesa_texstore_signed_rgba8888 },
+
+   { MESA_FORMAT_SIGNED_R16, _mesa_texstore_snorm16 },
+   { MESA_FORMAT_SIGNED_GR1616, _mesa_texstore_snorm1616 },
+   { MESA_FORMAT_SIGNED_RGB_16, _mesa_texstore_signed_rgba_16 },
+   { MESA_FORMAT_SIGNED_RGBA_16, _mesa_texstore_signed_rgba_16 },
+   { MESA_FORMAT_RGBA_16, _mesa_texstore_rgba_16 },
+
+   { MESA_FORMAT_RED_RGTC1, _mesa_texstore_red_rgtc1 },
+   { MESA_FORMAT_SIGNED_RED_RGTC1, _mesa_texstore_signed_red_rgtc1 },
+   { MESA_FORMAT_RG_RGTC2, _mesa_texstore_rg_rgtc2 },
+   { MESA_FORMAT_SIGNED_RG_RGTC2, _mesa_texstore_signed_rg_rgtc2 },
+
+   /* Re-use the R/RG texstore functions.
+    * The code is generic enough to handle LATC too. */
+   { MESA_FORMAT_L_LATC1, _mesa_texstore_red_rgtc1 },
+   { MESA_FORMAT_SIGNED_L_LATC1, _mesa_texstore_signed_red_rgtc1 },
+   { MESA_FORMAT_LA_LATC2, _mesa_texstore_rg_rgtc2 },
+   { MESA_FORMAT_SIGNED_LA_LATC2, _mesa_texstore_signed_rg_rgtc2 },
+
+   { MESA_FORMAT_SIGNED_A8, _mesa_texstore_snorm8 },
+   { MESA_FORMAT_SIGNED_L8, _mesa_texstore_snorm8 },
+   { MESA_FORMAT_SIGNED_AL88, _mesa_texstore_snorm88 },
+   { MESA_FORMAT_SIGNED_I8, _mesa_texstore_snorm8 },
+
+   { MESA_FORMAT_SIGNED_A16, _mesa_texstore_snorm16 },
+   { MESA_FORMAT_SIGNED_L16, _mesa_texstore_snorm16 },
+   { MESA_FORMAT_SIGNED_AL1616, _mesa_texstore_snorm1616 },
+   { MESA_FORMAT_SIGNED_I16, _mesa_texstore_snorm16 },
+
+   { MESA_FORMAT_RGB9_E5_FLOAT, _mesa_texstore_rgb9_e5 },
+   { MESA_FORMAT_R11_G11_B10_FLOAT, _mesa_texstore_r11_g11_b10f },
+};
+
+
+static GLboolean
+_mesa_texstore_null(TEXSTORE_PARAMS)
+{
+   (void) ctx; (void) dims;
+   (void) baseInternalFormat;
+   (void) dstFormat;
+   (void) dstAddr;
+   (void) dstXoffset; (void) dstYoffset; (void) dstZoffset;
+   (void) dstRowStride; (void) dstImageOffsets;
+   (void) srcWidth; (void) srcHeight; (void) srcDepth;
+   (void) srcFormat; (void) srcType;
+   (void) srcAddr;
+   (void) srcPacking;
+
+   /* should never happen */
+   _mesa_problem(NULL, "_mesa_texstore_null() is called");
+   return GL_FALSE;
+}
+
+
+/**
+ * Return the StoreTexImageFunc pointer to store an image in the given format.
+ */
+static StoreTexImageFunc
+_mesa_get_texstore_func(gl_format format)
+{
+#ifdef DEBUG
+   GLuint i;
+   for (i = 0; i < MESA_FORMAT_COUNT; i++) {
+      ASSERT(texstore_funcs[i].Name == i);
+   }
+#endif
+   ASSERT(texstore_funcs[format].Name == format);
+
+   if (texstore_funcs[format].Store)
+      return texstore_funcs[format].Store;
+   else
+      return _mesa_texstore_null;
+}
+
+
+/**
+ * Store user data into texture memory.
+ * Called via glTex[Sub]Image1/2/3D()
+ */
+GLboolean
+_mesa_texstore(TEXSTORE_PARAMS)
+{
+   StoreTexImageFunc storeImage;
+   GLboolean success;
+
+   storeImage = _mesa_get_texstore_func(dstFormat);
+
+   success = storeImage(ctx, dims, baseInternalFormat,
+                        dstFormat, dstAddr, dstXoffset, dstYoffset, dstZoffset,
+                        dstRowStride, dstImageOffsets,
+                        srcWidth, srcHeight, srcDepth,
+                        srcFormat, srcType, srcAddr, srcPacking);
+   return success;
+}
+
+
+/** Return texture size in bytes */
+static GLuint
+texture_size(const struct gl_texture_image *texImage)
+{
+   GLuint sz = _mesa_format_image_size(texImage->TexFormat, texImage->Width,
+                                       texImage->Height, texImage->Depth);
+   return sz;
+}
+
+
+/** Return row stride in bytes */
+static GLuint
+texture_row_stride(const struct gl_texture_image *texImage)
+{
+   GLuint stride = _mesa_format_row_stride(texImage->TexFormat,
+                                           texImage->Width);
+   return stride;
+}
+
+
+
+/**
+ * This is the software fallback for Driver.TexImage1D()
+ * and Driver.CopyTexImage1D().
+ * \sa _mesa_store_teximage2d()
+ */
+void
+_mesa_store_teximage1d(struct gl_context *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint border,
+                       GLenum format, GLenum type, const GLvoid *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLuint sizeInBytes;
+   (void) border;
+
+   /* allocate memory */
+   sizeInBytes = texture_size(texImage);
+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
+      return;
+   }
+
+   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,
+                                        pixels, packing, "glTexImage1D");
+   if (!pixels) {
+      /* Note: we check for a NULL image pointer here, _after_ we allocated
+       * memory for the texture.  That's what the GL spec calls for.
+       */
+      return;
+   }
+   else {
+      const GLint dstRowStride = 0;
+      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         0, 0, 0,  /* dstX/Y/Zoffset */
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, 1, 1,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage1D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+/**
+ * This is the software fallback for Driver.TexImage2D()
+ * and Driver.CopyTexImage2D().
+ *
+ * This function is oriented toward storing images in main memory, rather
+ * than VRAM.  Device driver's can easily plug in their own replacement.
+ */
+void
+_mesa_store_teximage2d(struct gl_context *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint border,
+                       GLenum format, GLenum type, const void *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLuint sizeInBytes;
+   (void) border;
+
+   /* allocate memory */
+   sizeInBytes = texture_size(texImage);
+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
+      return;
+   }
+
+   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,
+                                        pixels, packing, "glTexImage2D");
+   if (!pixels) {
+      /* Note: we check for a NULL image pointer here, _after_ we allocated
+       * memory for the texture.  That's what the GL spec calls for.
+       */
+      return;
+   }
+   else {
+      GLint dstRowStride = texture_row_stride(texImage);
+      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         0, 0, 0,  /* dstX/Y/Zoffset */
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, height, 1,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+
+/**
+ * This is the software fallback for Driver.TexImage3D()
+ * and Driver.CopyTexImage3D().
+ * \sa _mesa_store_teximage2d()
+ */
+void
+_mesa_store_teximage3d(struct gl_context *ctx, GLenum target, GLint level,
+                       GLint internalFormat,
+                       GLint width, GLint height, GLint depth, GLint border,
+                       GLenum format, GLenum type, const void *pixels,
+                       const struct gl_pixelstore_attrib *packing,
+                       struct gl_texture_object *texObj,
+                       struct gl_texture_image *texImage)
+{
+   GLuint sizeInBytes;
+   (void) border;
+
+   /* allocate memory */
+   sizeInBytes = texture_size(texImage);
+   texImage->Data = _mesa_alloc_texmemory(sizeInBytes);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
+      return;
+   }
+
+   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,
+                                        type, pixels, packing, "glTexImage3D");
+   if (!pixels) {
+      /* Note: we check for a NULL image pointer here, _after_ we allocated
+       * memory for the texture.  That's what the GL spec calls for.
+       */
+      return;
+   }
+   else {
+      GLint dstRowStride = texture_row_stride(texImage);
+      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         0, 0, 0,  /* dstX/Y/Zoffset */
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, height, depth,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage3D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+
+
+/*
+ * This is the software fallback for Driver.TexSubImage1D()
+ * and Driver.CopyTexSubImage1D().
+ */
+void
+_mesa_store_texsubimage1d(struct gl_context *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint width,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   /* get pointer to src pixels (may be in a pbo which we'll map here) */
+   pixels = _mesa_validate_pbo_teximage(ctx, 1, width, 1, 1, format, type,
+                                        pixels, packing, "glTexSubImage1D");
+   if (!pixels)
+      return;
+
+   {
+      const GLint dstRowStride = 0;
+      GLboolean success = _mesa_texstore(ctx, 1, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         xoffset, 0, 0,  /* offsets */
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, 1, 1,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage1D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+
+/**
+ * This is the software fallback for Driver.TexSubImage2D()
+ * and Driver.CopyTexSubImage2D().
+ */
+void
+_mesa_store_texsubimage2d(struct gl_context *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset,
+                          GLint width, GLint height,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   /* get pointer to src pixels (may be in a pbo which we'll map here) */
+   pixels = _mesa_validate_pbo_teximage(ctx, 2, width, height, 1, format, type,
+                                        pixels, packing, "glTexSubImage2D");
+   if (!pixels)
+      return;
+
+   {
+      GLint dstRowStride = texture_row_stride(texImage);
+      GLboolean success = _mesa_texstore(ctx, 2, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         xoffset, yoffset, 0,
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, height, 1,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage2D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+/*
+ * This is the software fallback for Driver.TexSubImage3D().
+ * and Driver.CopyTexSubImage3D().
+ */
+void
+_mesa_store_texsubimage3d(struct gl_context *ctx, GLenum target, GLint level,
+                          GLint xoffset, GLint yoffset, GLint zoffset,
+                          GLint width, GLint height, GLint depth,
+                          GLenum format, GLenum type, const void *pixels,
+                          const struct gl_pixelstore_attrib *packing,
+                          struct gl_texture_object *texObj,
+                          struct gl_texture_image *texImage)
+{
+   /* get pointer to src pixels (may be in a pbo which we'll map here) */
+   pixels = _mesa_validate_pbo_teximage(ctx, 3, width, height, depth, format,
+                                        type, pixels, packing,
+                                        "glTexSubImage3D");
+   if (!pixels)
+      return;
+
+   {
+      GLint dstRowStride = texture_row_stride(texImage);
+      GLboolean success = _mesa_texstore(ctx, 3, texImage->_BaseFormat,
+                                         texImage->TexFormat,
+                                         texImage->Data,
+                                         xoffset, yoffset, zoffset,
+                                         dstRowStride,
+                                         texImage->ImageOffsets,
+                                         width, height, depth,
+                                         format, type, pixels, packing);
+      if (!success) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage3D");
+      }
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, packing);
+}
+
+
+/*
+ * Fallback for Driver.CompressedTexImage1D()
+ */
+void
+_mesa_store_compressed_teximage1d(struct gl_context *ctx,
+                                  GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   /* this space intentionally left blank */
+   (void) ctx;
+   (void) target; (void) level;
+   (void) internalFormat;
+   (void) width; (void) border;
+   (void) imageSize; (void) data;
+   (void) texObj;
+   (void) texImage;
+}
+
+
+
+/**
+ * Fallback for Driver.CompressedTexImage2D()
+ */
+void
+_mesa_store_compressed_teximage2d(struct gl_context *ctx,
+                                  GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint height, GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   (void) width; (void) height; (void) border;
+
+   /* This is pretty simple, basically just do a memcpy without worrying
+    * about the usual image unpacking or image transfer operations.
+    */
+   ASSERT(texObj);
+   ASSERT(texImage);
+   ASSERT(texImage->Width > 0);
+   ASSERT(texImage->Height > 0);
+   ASSERT(texImage->Depth == 1);
+   ASSERT(texImage->Data == NULL); /* was freed in glCompressedTexImage2DARB */
+
+   /* allocate storage */
+   texImage->Data = _mesa_alloc_texmemory(imageSize);
+   if (!texImage->Data) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
+      return;
+   }
+
+   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,
+                                                 &ctx->Unpack,
+                                                 "glCompressedTexImage2D");
+   if (!data)
+      return;
+
+   /* copy the data */
+   memcpy(texImage->Data, data, imageSize);
+
+   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
+}
+
+
+
+/*
+ * Fallback for Driver.CompressedTexImage3D()
+ */
+void
+_mesa_store_compressed_teximage3d(struct gl_context *ctx,
+                                  GLenum target, GLint level,
+                                  GLint internalFormat,
+                                  GLint width, GLint height, GLint depth,
+                                  GLint border,
+                                  GLsizei imageSize, const GLvoid *data,
+                                  struct gl_texture_object *texObj,
+                                  struct gl_texture_image *texImage)
+{
+   /* this space intentionally left blank */
+   (void) ctx;
+   (void) target; (void) level;
+   (void) internalFormat;
+   (void) width; (void) height; (void) depth;
+   (void) border;
+   (void) imageSize; (void) data;
+   (void) texObj;
+   (void) texImage;
+}
+
+
+
+/**
+ * Fallback for Driver.CompressedTexSubImage1D()
+ */
+void
+_mesa_store_compressed_texsubimage1d(struct gl_context *ctx, GLenum target,
+                                     GLint level,
+                                     GLint xoffset, GLsizei width,
+                                     GLenum format,
+                                     GLsizei imageSize, const GLvoid *data,
+                                     struct gl_texture_object *texObj,
+                                     struct gl_texture_image *texImage)
+{
+   /* there are no compressed 1D texture formats yet */
+   (void) ctx;
+   (void) target; (void) level;
+   (void) xoffset; (void) width;
+   (void) format;
+   (void) imageSize; (void) data;
+   (void) texObj;
+   (void) texImage;
+}
+
+
+/**
+ * Fallback for Driver.CompressedTexSubImage2D()
+ */
+void
+_mesa_store_compressed_texsubimage2d(struct gl_context *ctx, GLenum target,
+                                     GLint level,
+                                     GLint xoffset, GLint yoffset,
+                                     GLsizei width, GLsizei height,
+                                     GLenum format,
+                                     GLsizei imageSize, const GLvoid *data,
+                                     struct gl_texture_object *texObj,
+                                     struct gl_texture_image *texImage)
+{
+   GLint bytesPerRow, destRowStride, srcRowStride;
+   GLint i, rows;
+   GLubyte *dest;
+   const GLubyte *src;
+   const gl_format texFormat = texImage->TexFormat;
+   const GLint destWidth = texImage->Width;
+   GLuint bw, bh;
+
+   _mesa_get_format_block_size(texFormat, &bw, &bh);
+
+   (void) level;
+   (void) format;
+
+   /* these should have been caught sooner */
+   ASSERT((width % bw) == 0 || width == 2 || width == 1);
+   ASSERT((height % bh) == 0 || height == 2 || height == 1);
+   ASSERT((xoffset % bw) == 0);
+   ASSERT((yoffset % bh) == 0);
+
+   /* get pointer to src pixels (may be in a pbo which we'll map here) */
+   data = _mesa_validate_pbo_compressed_teximage(ctx, imageSize, data,
+                                                 &ctx->Unpack,
+                                                 "glCompressedTexSubImage2D");
+   if (!data)
+      return;
+
+   srcRowStride = _mesa_format_row_stride(texFormat, width);
+   src = (const GLubyte *) data;
+
+   destRowStride = _mesa_format_row_stride(texFormat, destWidth);
+   dest = _mesa_compressed_image_address(xoffset, yoffset, 0,
+                                         texFormat, destWidth,
+                                         (GLubyte *) texImage->Data);
+
+   bytesPerRow = srcRowStride;  /* bytes per row of blocks */
+   rows = height / bh;  /* rows in blocks */
+
+   /* copy rows of blocks */
+   for (i = 0; i < rows; i++) {
+      memcpy(dest, src, bytesPerRow);
+      dest += destRowStride;
+      src += srcRowStride;
+   }
+
+   _mesa_unmap_teximage_pbo(ctx, &ctx->Unpack);
+}
+
+
+/**
+ * Fallback for Driver.CompressedTexSubImage3D()
+ */
+void
+_mesa_store_compressed_texsubimage3d(struct gl_context *ctx, GLenum target,
+                                GLint level,
+                                GLint xoffset, GLint yoffset, GLint zoffset,
+                                GLsizei width, GLsizei height, GLsizei depth,
+                                GLenum format,
+                                GLsizei imageSize, const GLvoid *data,
+                                struct gl_texture_object *texObj,
+                                struct gl_texture_image *texImage)
+{
+   /* there are no compressed 3D texture formats yet */
+   (void) ctx;
+   (void) target; (void) level;
+   (void) xoffset; (void) yoffset; (void) zoffset;
+   (void) width; (void) height; (void) depth;
+   (void) format;
+   (void) imageSize; (void) data;
+   (void) texObj;
+   (void) texImage;
+}
diff --git a/mesalib/src/mesa/state_tracker/st_cb_texture.c b/mesalib/src/mesa/state_tracker/st_cb_texture.c
index 2def3d138..ce289fc6b 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_texture.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_texture.c
@@ -1241,7 +1241,8 @@ fallback_copy_texsubimage(struct gl_context *ctx, GLenum target, GLint level,
 

    src_trans = pipe_get_transfer(pipe,

                                  strb->texture,

-                                 0, 0,

+                                 strb->rtt_level,

+                                 strb->rtt_face + strb->rtt_slice,

                                  PIPE_TRANSFER_READ,

                                  srcX, srcY,

                                  width, height);

diff --git a/mesalib/src/mesa/state_tracker/st_draw.c b/mesalib/src/mesa/state_tracker/st_draw.c
index 6d86e1310..3b1fab04e 100644
--- a/mesalib/src/mesa/state_tracker/st_draw.c
+++ b/mesalib/src/mesa/state_tracker/st_draw.c
@@ -233,6 +233,22 @@ st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
 }

 

 

+/**

+ * This is very similar to vbo_all_varyings_in_vbos() but we test

+ * the stride.  See bug 38626.

+ */

+static GLboolean

+all_varyings_in_vbos(const struct gl_client_array *arrays[])

+{

+   GLuint i;

+   

+   for (i = 0; i < VERT_ATTRIB_MAX; i++)

+      if (arrays[i]->StrideB && !_mesa_is_bufferobj(arrays[i]->BufferObj))

+	 return GL_FALSE;

+

+   return GL_TRUE;

+}

+

 

 /**

  * Examine the active arrays to determine if we have interleaved

@@ -648,7 +664,7 @@ st_draw_vbo(struct gl_context *ctx,
    if (ib) {

       /* Gallium probably doesn't want this in some cases. */

       if (!index_bounds_valid)

-         if (!vbo_all_varyings_in_vbos(arrays))

+         if (!all_varyings_in_vbos(arrays))

             vbo_get_minmax_index(ctx, prims, ib, &min_index, &max_index);

 

       for (i = 0; i < nr_prims; i++) {

diff --git a/mesalib/src/mesa/state_tracker/st_format.c b/mesalib/src/mesa/state_tracker/st_format.c
index b0a00ce12..6964cdbb4 100644
--- a/mesalib/src/mesa/state_tracker/st_format.c
+++ b/mesalib/src/mesa/state_tracker/st_format.c
@@ -616,7 +616,7 @@ static const struct format_mapping format_map[] = {
    },

    {

       { 4, GL_RGBA, GL_RGBA8, 0 },

-      { DEFAULT_RGBA_FORMATS }

+      { PIPE_FORMAT_R8G8B8A8_UNORM, DEFAULT_RGBA_FORMATS }

    },

    {

       { GL_BGRA, 0 },

@@ -1147,24 +1147,28 @@ static const struct exact_format_mapping rgba8888_tbl[] =
 

 static const struct exact_format_mapping rgbx8888_tbl[] =

 {

+   { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_X8R8G8B8_UNORM },

+   { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_B8G8R8X8_UNORM },

+   { GL_BGRA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_B8G8R8X8_UNORM },

+   /* No Mesa formats for these Gallium formats:

    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_X8B8G8R8_UNORM },

    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_X8B8G8R8_UNORM },

    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_R8G8B8X8_UNORM },

    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_R8G8B8X8_UNORM },

-   { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_X8R8G8B8_UNORM },

-   { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_B8G8R8X8_UNORM },

    { GL_RGBA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_R8G8B8X8_UNORM },

    { GL_ABGR_EXT, GL_UNSIGNED_BYTE,               PIPE_FORMAT_X8B8G8R8_UNORM },

-   { GL_BGRA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_B8G8R8X8_UNORM },

+   */

    { 0,           0,                              0                          }

 };

 

 static const struct exact_format_mapping rgba1010102_tbl[] =

 {

    { GL_BGRA,     GL_UNSIGNED_INT_2_10_10_10_REV, PIPE_FORMAT_B10G10R10A2_UNORM },

+   /* No Mesa formats for these Gallium formats:

    { GL_RGBA,     GL_UNSIGNED_INT_2_10_10_10_REV, PIPE_FORMAT_R10G10B10A2_UNORM },

    { GL_ABGR_EXT, GL_UNSIGNED_INT_10_10_10_2,     PIPE_FORMAT_R10G10B10A2_UNORM },

    { GL_ABGR_EXT, GL_UNSIGNED_INT,                PIPE_FORMAT_R10G10B10A2_UNORM },

+   */

    { 0,           0,                              0                             }

 };

 

diff --git a/mesalib/src/mesa/vbo/vbo_rebase.c b/mesalib/src/mesa/vbo/vbo_rebase.c
index a62777cbf..1de290ff6 100644
--- a/mesalib/src/mesa/vbo/vbo_rebase.c
+++ b/mesalib/src/mesa/vbo/vbo_rebase.c
@@ -1,251 +1,249 @@
-

-/*

- * Mesa 3-D graphics library

- * Version:  6.5

- *

- * Copyright (C) 1999-2006  Brian Paul   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

- * 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 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

- * BRIAN PAUL 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:

- *    Keith Whitwell <keith@tungstengraphics.com>

- */

-

-/* Helper for drivers which find themselves rendering a range of

- * indices starting somewhere above zero.  Typically the application

- * is issuing multiple DrawArrays() or DrawElements() to draw

- * successive primitives layed out linearly in the vertex arrays.

- * Unless the vertex arrays are all in a VBO, the OpenGL semantics

- * imply that we need to re-upload the vertex data on each draw call.

- * In that case, we want to avoid starting the upload at zero, as it

- * will mean every draw call uploads an increasing amount of not-used

- * vertex data.  Worse - in the software tnl module, all those

- * vertices will be transformed and lit.

- *

- * If we just upload the new data, however, the indices will be

- * incorrect as we tend to upload each set of vertex data to a new

- * region.  

- *

- * This file provides a helper to adjust the arrays, primitives and

- * indices of a draw call so that it can be re-issued with a min_index

- * of zero.

- */

-

-#include "main/glheader.h"

-#include "main/imports.h"

-#include "main/mtypes.h"

-

-#include "vbo.h"

-

-

-#define REBASE(TYPE) 						\

-static void *rebase_##TYPE( const void *ptr,			\

-			  GLuint count, 			\

-			  TYPE min_index )			\

-{								\

-   const TYPE *in = (TYPE *)ptr;				\

-   TYPE *tmp_indices = malloc(count * sizeof(TYPE));	\

-   GLuint i;							\

-								\

-   for (i = 0; i < count; i++)  				\

-      tmp_indices[i] = in[i] - min_index;			\

-								\

-   return (void *)tmp_indices;					\

-}

-

-

-REBASE(GLuint)

-REBASE(GLushort)

-REBASE(GLubyte)

-

-GLboolean vbo_all_varyings_in_vbos( const struct gl_client_array *arrays[] )

-{

-   GLuint i;

-   

-   for (i = 0; i < VERT_ATTRIB_MAX; i++)

-      if (arrays[i]->StrideB &&

-	  arrays[i]->BufferObj->Name == 0)

-	 return GL_FALSE;

-

-   return GL_TRUE;

-}

-

-GLboolean vbo_any_varyings_in_vbos( const struct gl_client_array *arrays[] )

-{

-   GLuint i;

-

-   for (i = 0; i < VERT_ATTRIB_MAX; i++)

-      if (arrays[i]->StrideB &&

-	  arrays[i]->BufferObj->Name != 0)

-	 return GL_TRUE;

-

-   return GL_FALSE;

-}

-

-/* Adjust primitives, indices and vertex definitions so that min_index

- * becomes zero. There are lots of reasons for wanting to do this, eg:

- *

- * Software tnl:

- *    - any time min_index != 0, otherwise unused vertices lower than

- *      min_index will be transformed.

- *

- * Hardware tnl:

- *    - if ib != NULL and min_index != 0, otherwise vertices lower than 

- *      min_index will be uploaded.  Requires adjusting index values.

- *

- *    - if ib == NULL and min_index != 0, just for convenience so this doesn't

- *      have to be handled within the driver.

- *

- * Hardware tnl with VBO support:

- *    - as above, but only when vertices are not (all?) in VBO's.

- *    - can't save time by trying to upload half a vbo - typically it is

- *      all or nothing.

- */

-void vbo_rebase_prims( struct gl_context *ctx,

-		       const struct gl_client_array *arrays[],

-		       const struct _mesa_prim *prim,

-		       GLuint nr_prims,

-		       const struct _mesa_index_buffer *ib,

-		       GLuint min_index,

-		       GLuint max_index,

-		       vbo_draw_func draw )

-{

-   struct gl_client_array tmp_arrays[VERT_ATTRIB_MAX];

-   const struct gl_client_array *tmp_array_pointers[VERT_ATTRIB_MAX];

-

-   struct _mesa_index_buffer tmp_ib;

-   struct _mesa_prim *tmp_prims = NULL;

-   void *tmp_indices = NULL;

-   GLuint i;

-

-   assert(min_index != 0);

-

-   if (0)

-      printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);

-

-

-   /* XXX this path is disabled for now.

-    * There's rendering corruption in some apps when it's enabled.

-    */

-   if (0 && ib && ctx->Extensions.ARB_draw_elements_base_vertex) {

-      /* If we can just tell the hardware or the TNL to interpret our

-       * indices with a different base, do so.

-       */

-      tmp_prims = (struct _mesa_prim *)malloc(sizeof(*prim) * nr_prims);

-

-      for (i = 0; i < nr_prims; i++) {

-	 tmp_prims[i] = prim[i];

-	 tmp_prims[i].basevertex -= min_index;

-      }

-

-      prim = tmp_prims;

-   } else if (ib) {

-      /* Unfortunately need to adjust each index individually.

-       */

-      GLboolean map_ib = ib->obj->Name && !ib->obj->Pointer;

-      void *ptr;

-

-      if (map_ib) 

-	 ctx->Driver.MapBuffer(ctx, 

-			       GL_ELEMENT_ARRAY_BUFFER,

-			       GL_READ_ONLY_ARB,

-			       ib->obj);

-

-

-      ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);

-

-      /* Some users might prefer it if we translated elements to

-       * GLuints here.  Others wouldn't...

-       */

-      switch (ib->type) {

-      case GL_UNSIGNED_INT: 

-	 tmp_indices = rebase_GLuint( ptr, ib->count, min_index );

-	 break;

-      case GL_UNSIGNED_SHORT: 

-	 tmp_indices = rebase_GLushort( ptr, ib->count, min_index );

-	 break;

-      case GL_UNSIGNED_BYTE: 

-	 tmp_indices = rebase_GLubyte( ptr, ib->count, min_index );

-	 break;

-      }      

-

-      if (map_ib) 

-	 ctx->Driver.UnmapBuffer(ctx, 

-				 GL_ELEMENT_ARRAY_BUFFER,

-				 ib->obj);

-

-      tmp_ib.obj = ctx->Shared->NullBufferObj;

-      tmp_ib.ptr = tmp_indices;

-      tmp_ib.count = ib->count;

-      tmp_ib.type = ib->type;

-

-      ib = &tmp_ib;

-   }

-   else {

-      /* Otherwise the primitives need adjustment.

-       */

-      tmp_prims = (struct _mesa_prim *)malloc(sizeof(*prim) * nr_prims);

-

-      for (i = 0; i < nr_prims; i++) {

-	 /* If this fails, it could indicate an application error:

-	  */

-	 assert(prim[i].start >= min_index);

-

-	 tmp_prims[i] = prim[i];

-	 tmp_prims[i].start -= min_index;

-      }

-

-      prim = tmp_prims;

-   }

-

-   /* Just need to adjust the pointer values on each incoming array.

-    * This works for VBO and non-vbo rendering and shouldn't pesimize

-    * VBO-based upload schemes.  However this may still not be a fast

-    * path for hardware tnl for VBO based rendering as most machines

-    * will be happier if you just specify a starting vertex value in

-    * each primitive.

-    *

-    * For drivers with hardware tnl, you only want to do this if you

-    * are forced to, eg non-VBO indexed rendering with start != 0.

-    */

-   for (i = 0; i < VERT_ATTRIB_MAX; i++) {

-      tmp_arrays[i] = *arrays[i];

-      tmp_arrays[i].Ptr += min_index * tmp_arrays[i].StrideB;

-      tmp_array_pointers[i] = &tmp_arrays[i];

-   }

-   

-   /* Re-issue the draw call.

-    */

-   draw( ctx, 

-	 tmp_array_pointers, 

-	 prim, 

-	 nr_prims, 

-	 ib, 

-	 GL_TRUE,

-	 0, 

-	 max_index - min_index );

-   

-   if (tmp_indices)

-      free(tmp_indices);

-   

-   if (tmp_prims)

-      free(tmp_prims);

-}

-

-

-

+
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  Brian Paul   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
+ * 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 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
+ * BRIAN PAUL 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:
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+/* Helper for drivers which find themselves rendering a range of
+ * indices starting somewhere above zero.  Typically the application
+ * is issuing multiple DrawArrays() or DrawElements() to draw
+ * successive primitives layed out linearly in the vertex arrays.
+ * Unless the vertex arrays are all in a VBO, the OpenGL semantics
+ * imply that we need to re-upload the vertex data on each draw call.
+ * In that case, we want to avoid starting the upload at zero, as it
+ * will mean every draw call uploads an increasing amount of not-used
+ * vertex data.  Worse - in the software tnl module, all those
+ * vertices will be transformed and lit.
+ *
+ * If we just upload the new data, however, the indices will be
+ * incorrect as we tend to upload each set of vertex data to a new
+ * region.  
+ *
+ * This file provides a helper to adjust the arrays, primitives and
+ * indices of a draw call so that it can be re-issued with a min_index
+ * of zero.
+ */
+
+#include "main/glheader.h"
+#include "main/imports.h"
+#include "main/mtypes.h"
+
+#include "vbo.h"
+
+
+#define REBASE(TYPE) 						\
+static void *rebase_##TYPE( const void *ptr,			\
+			  GLuint count, 			\
+			  TYPE min_index )			\
+{								\
+   const TYPE *in = (TYPE *)ptr;				\
+   TYPE *tmp_indices = malloc(count * sizeof(TYPE));	\
+   GLuint i;							\
+								\
+   for (i = 0; i < count; i++)  				\
+      tmp_indices[i] = in[i] - min_index;			\
+								\
+   return (void *)tmp_indices;					\
+}
+
+
+REBASE(GLuint)
+REBASE(GLushort)
+REBASE(GLubyte)
+
+GLboolean vbo_all_varyings_in_vbos( const struct gl_client_array *arrays[] )
+{
+   GLuint i;
+   
+   for (i = 0; i < VERT_ATTRIB_MAX; i++)
+      if (arrays[i]->BufferObj->Name == 0)
+	 return GL_FALSE;
+
+   return GL_TRUE;
+}
+
+GLboolean vbo_any_varyings_in_vbos( const struct gl_client_array *arrays[] )
+{
+   GLuint i;
+
+   for (i = 0; i < VERT_ATTRIB_MAX; i++)
+      if (arrays[i]->BufferObj->Name != 0)
+	 return GL_TRUE;
+
+   return GL_FALSE;
+}
+
+/* Adjust primitives, indices and vertex definitions so that min_index
+ * becomes zero. There are lots of reasons for wanting to do this, eg:
+ *
+ * Software tnl:
+ *    - any time min_index != 0, otherwise unused vertices lower than
+ *      min_index will be transformed.
+ *
+ * Hardware tnl:
+ *    - if ib != NULL and min_index != 0, otherwise vertices lower than 
+ *      min_index will be uploaded.  Requires adjusting index values.
+ *
+ *    - if ib == NULL and min_index != 0, just for convenience so this doesn't
+ *      have to be handled within the driver.
+ *
+ * Hardware tnl with VBO support:
+ *    - as above, but only when vertices are not (all?) in VBO's.
+ *    - can't save time by trying to upload half a vbo - typically it is
+ *      all or nothing.
+ */
+void vbo_rebase_prims( struct gl_context *ctx,
+		       const struct gl_client_array *arrays[],
+		       const struct _mesa_prim *prim,
+		       GLuint nr_prims,
+		       const struct _mesa_index_buffer *ib,
+		       GLuint min_index,
+		       GLuint max_index,
+		       vbo_draw_func draw )
+{
+   struct gl_client_array tmp_arrays[VERT_ATTRIB_MAX];
+   const struct gl_client_array *tmp_array_pointers[VERT_ATTRIB_MAX];
+
+   struct _mesa_index_buffer tmp_ib;
+   struct _mesa_prim *tmp_prims = NULL;
+   void *tmp_indices = NULL;
+   GLuint i;
+
+   assert(min_index != 0);
+
+   if (0)
+      printf("%s %d..%d\n", __FUNCTION__, min_index, max_index);
+
+
+   /* XXX this path is disabled for now.
+    * There's rendering corruption in some apps when it's enabled.
+    */
+   if (0 && ib && ctx->Extensions.ARB_draw_elements_base_vertex) {
+      /* If we can just tell the hardware or the TNL to interpret our
+       * indices with a different base, do so.
+       */
+      tmp_prims = (struct _mesa_prim *)malloc(sizeof(*prim) * nr_prims);
+
+      for (i = 0; i < nr_prims; i++) {
+	 tmp_prims[i] = prim[i];
+	 tmp_prims[i].basevertex -= min_index;
+      }
+
+      prim = tmp_prims;
+   } else if (ib) {
+      /* Unfortunately need to adjust each index individually.
+       */
+      GLboolean map_ib = ib->obj->Name && !ib->obj->Pointer;
+      void *ptr;
+
+      if (map_ib) 
+	 ctx->Driver.MapBuffer(ctx, 
+			       GL_ELEMENT_ARRAY_BUFFER,
+			       GL_READ_ONLY_ARB,
+			       ib->obj);
+
+
+      ptr = ADD_POINTERS(ib->obj->Pointer, ib->ptr);
+
+      /* Some users might prefer it if we translated elements to
+       * GLuints here.  Others wouldn't...
+       */
+      switch (ib->type) {
+      case GL_UNSIGNED_INT: 
+	 tmp_indices = rebase_GLuint( ptr, ib->count, min_index );
+	 break;
+      case GL_UNSIGNED_SHORT: 
+	 tmp_indices = rebase_GLushort( ptr, ib->count, min_index );
+	 break;
+      case GL_UNSIGNED_BYTE: 
+	 tmp_indices = rebase_GLubyte( ptr, ib->count, min_index );
+	 break;
+      }      
+
+      if (map_ib) 
+	 ctx->Driver.UnmapBuffer(ctx, 
+				 GL_ELEMENT_ARRAY_BUFFER,
+				 ib->obj);
+
+      tmp_ib.obj = ctx->Shared->NullBufferObj;
+      tmp_ib.ptr = tmp_indices;
+      tmp_ib.count = ib->count;
+      tmp_ib.type = ib->type;
+
+      ib = &tmp_ib;
+   }
+   else {
+      /* Otherwise the primitives need adjustment.
+       */
+      tmp_prims = (struct _mesa_prim *)malloc(sizeof(*prim) * nr_prims);
+
+      for (i = 0; i < nr_prims; i++) {
+	 /* If this fails, it could indicate an application error:
+	  */
+	 assert(prim[i].start >= min_index);
+
+	 tmp_prims[i] = prim[i];
+	 tmp_prims[i].start -= min_index;
+      }
+
+      prim = tmp_prims;
+   }
+
+   /* Just need to adjust the pointer values on each incoming array.
+    * This works for VBO and non-vbo rendering and shouldn't pesimize
+    * VBO-based upload schemes.  However this may still not be a fast
+    * path for hardware tnl for VBO based rendering as most machines
+    * will be happier if you just specify a starting vertex value in
+    * each primitive.
+    *
+    * For drivers with hardware tnl, you only want to do this if you
+    * are forced to, eg non-VBO indexed rendering with start != 0.
+    */
+   for (i = 0; i < VERT_ATTRIB_MAX; i++) {
+      tmp_arrays[i] = *arrays[i];
+      tmp_arrays[i].Ptr += min_index * tmp_arrays[i].StrideB;
+      tmp_array_pointers[i] = &tmp_arrays[i];
+   }
+   
+   /* Re-issue the draw call.
+    */
+   draw( ctx, 
+	 tmp_array_pointers, 
+	 prim, 
+	 nr_prims, 
+	 ib, 
+	 GL_TRUE,
+	 0, 
+	 max_index - min_index );
+   
+   if (tmp_indices)
+      free(tmp_indices);
+   
+   if (tmp_prims)
+      free(tmp_prims);
+}
+
+
+
diff --git a/pixman/configure.ac b/pixman/configure.ac
index cf3a89fe5..7f2f28217 100644
--- a/pixman/configure.ac
+++ b/pixman/configure.ac
@@ -90,7 +90,7 @@ AC_DEFUN([PIXMAN_LINK_WITH_ENV],[dnl
 	LIBS=""

 	$1

 	AC_LINK_IFELSE(

-		[$2],

+		[AC_LANG_SOURCE([$2])],

 		[pixman_cc_stderr=`test -f conftest.err && cat conftest.err`

 		 pixman_cc_flag=yes],

 		[pixman_cc_stderr=`test -f conftest.err && cat conftest.err`

@@ -290,7 +290,7 @@ have_mmx_intrinsics=no
 AC_MSG_CHECKING(whether to use MMX intrinsics)

 xserver_save_CFLAGS=$CFLAGS

 CFLAGS="$MMX_CFLAGS $CFLAGS"

-AC_COMPILE_IFELSE([

+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

 #if defined(__GNUC__) && (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4))

 error "Need GCC >= 3.4 for MMX intrinsics"

 #endif

@@ -298,7 +298,7 @@ error "Need GCC >= 3.4 for MMX intrinsics"
 int main () {

     __m64 v = _mm_cvtsi32_si64 (1);

     return _mm_cvtsi64_si32 (v);

-}], have_mmx_intrinsics=yes)

+}]])], have_mmx_intrinsics=yes)

 CFLAGS=$xserver_save_CFLAGS

 

 AC_ARG_ENABLE(mmx,

@@ -342,7 +342,7 @@ AC_MSG_CHECKING(whether to use SSE2 intrinsics)
 xserver_save_CFLAGS=$CFLAGS

 CFLAGS="$SSE2_CFLAGS $CFLAGS"

 

-AC_COMPILE_IFELSE([

+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

 #if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2))

 #   if !defined(__amd64__) && !defined(__x86_64__)

 #      error "Need GCC >= 4.2 for SSE2 intrinsics on x86"

@@ -355,7 +355,7 @@ int main () {
     __m128i a = _mm_set1_epi32 (0), b = _mm_set1_epi32 (0), c;

 	c = _mm_xor_si128 (a, b);

     return 0;

-}], have_sse2_intrinsics=yes)

+}]])], have_sse2_intrinsics=yes)

 CFLAGS=$xserver_save_CFLAGS

 

 AC_ARG_ENABLE(sse2,

@@ -392,7 +392,7 @@ case $host_os in
 	 hwcap_save_LDFLAGS="$LDFLAGS"

 	 HWCAP_LDFLAGS='-Wl,-M,$(srcdir)/solaris-hwcap.mapfile'

 	 LDFLAGS="$LDFLAGS -Wl,-M,pixman/solaris-hwcap.mapfile"

-	 AC_LINK_IFELSE([int main() { return 0; }],

+	 AC_LINK_IFELSE([AC_LANG_SOURCE([[int main() { return 0; }]])],

 			use_hwcap_mapfile=yes,

 			HWCAP_LDFLAGS="")

 	 LDFLAGS="$hwcap_save_LDFLAGS"

@@ -424,7 +424,7 @@ have_vmx_intrinsics=no
 AC_MSG_CHECKING(whether to use VMX/Altivec intrinsics)

 xserver_save_CFLAGS=$CFLAGS

 CFLAGS="$VMX_CFLAGS $CFLAGS"

-AC_COMPILE_IFELSE([

+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

 #if defined(__GNUC__) && (__GNUC__ < 3 || (__GNUC__ == 3 && __GNUC_MINOR__ < 4))

 error "Need GCC >= 3.4 for sane altivec support"

 #endif

@@ -433,7 +433,7 @@ int main () {
     vector unsigned int v = vec_splat_u32 (1);

     v = vec_sub (v, v);

     return 0;

-}], have_vmx_intrinsics=yes)

+}]])], have_vmx_intrinsics=yes)

 CFLAGS=$xserver_save_CFLAGS

 

 AC_ARG_ENABLE(vmx,

@@ -466,7 +466,7 @@ have_arm_simd=no
 AC_MSG_CHECKING(whether to use ARM SIMD assembler)

 xserver_save_CFLAGS=$CFLAGS

 CFLAGS="-x assembler-with-cpp $CFLAGS"

-AC_COMPILE_IFELSE([[

+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

 .text

 .arch armv6

 .object_arch armv4

@@ -476,7 +476,7 @@ AC_COMPILE_IFELSE([[
 #error EABI is required (to be sure that calling conventions are compatible)

 #endif

 pld [r0]

-uqadd8 r0, r0, r0]], have_arm_simd=yes)

+uqadd8 r0, r0, r0]])], have_arm_simd=yes)

 CFLAGS=$xserver_save_CFLAGS

 

 AC_ARG_ENABLE(arm-simd,

@@ -505,7 +505,7 @@ have_arm_neon=no
 AC_MSG_CHECKING(whether to use ARM NEON assembler)

 xserver_save_CFLAGS=$CFLAGS

 CFLAGS="-x assembler-with-cpp $CFLAGS"

-AC_COMPILE_IFELSE([[

+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

 .text

 .fpu neon

 .arch armv7a

@@ -517,7 +517,7 @@ AC_COMPILE_IFELSE([[
 #error EABI is required (to be sure that calling conventions are compatible)

 #endif

 pld [r0]

-vmovn.u16 d0, q0]], have_arm_neon=yes)

+vmovn.u16 d0, q0]])], have_arm_neon=yes)

 CFLAGS=$xserver_save_CFLAGS

 

 AC_ARG_ENABLE(arm-neon,

@@ -545,12 +545,12 @@ dnl Check for GNU-style inline assembly support
 

 have_gcc_inline_asm=no

 AC_MSG_CHECKING(whether to use GNU-style inline assembler)

-AC_COMPILE_IFELSE([

+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[

 int main () {

     /* Most modern architectures have a NOP instruction, so this is a fairly generic test. */

 	asm volatile ( "\tnop\n" : : : "cc", "memory" );

     return 0;

-}], have_gcc_inline_asm=yes)

+}]])], have_gcc_inline_asm=yes)

 

 AC_ARG_ENABLE(gcc-inline-asm,

    [AC_HELP_STRING([--disable-gcc-inline-asm],

@@ -685,7 +685,7 @@ dnl Thread local storage
 support_for__thread=no

 

 AC_MSG_CHECKING(for __thread)

-AC_LINK_IFELSE([

+AC_LINK_IFELSE([AC_LANG_SOURCE([[

 #if defined(__MINGW32__) && !(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))

 #error This MinGW version has broken __thread support

 #endif

@@ -694,7 +694,7 @@ AC_LINK_IFELSE([
 #endif

 static __thread int x ;

 int main () { x = 123; return x; }

-], support_for__thread=yes)

+]])], support_for__thread=yes)

 

 if test $support_for__thread = yes; then 

    AC_DEFINE([TOOLCHAIN_SUPPORTS__THREAD],[],[Whether the tool chain supports __thread])

@@ -706,7 +706,7 @@ dnl
 dnl posix tls

 dnl

 

-m4_define([pthread_test_program],[dnl

+m4_define([pthread_test_program],AC_LANG_SOURCE([[dnl

 #include <stdlib.h>

 #include <pthread.h>

 

@@ -739,7 +739,7 @@ main ()
     }

     return 0;

 }

-])

+]]))

 

 AC_DEFUN([PIXMAN_CHECK_PTHREAD],[dnl

     if test "z$support_for_pthread_setspecific" != "zyes"; then

@@ -780,7 +780,7 @@ dnl __attribute__((constructor))
 support_for_attribute_constructor=no

 

 AC_MSG_CHECKING(for __attribute__((constructor)))

-AC_LINK_IFELSE([

+AC_LINK_IFELSE([AC_LANG_SOURCE([[

 #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7))

 /* attribute 'constructor' is supported since gcc 2.7, but some compilers

  * may only pretend to be gcc, so let's try to actually use it

@@ -791,7 +791,7 @@ int main (void) { return x; }
 #else

 #error not gcc or gcc version is older than 2.7

 #endif

-], support_for_attribute_constructor=yes)

+]])], support_for_attribute_constructor=yes)

 

 if test x$support_for_attribute_constructor = xyes; then

    AC_DEFINE([TOOLCHAIN_SUPPORTS_ATTRIBUTE_CONSTRUCTOR],

diff --git a/pixman/pixman/pixman-arm-neon-asm.S b/pixman/pixman/pixman-arm-neon-asm.S
index 4b0532831..4f96174d9 100644
--- a/pixman/pixman/pixman-arm-neon-asm.S
+++ b/pixman/pixman/pixman-arm-neon-asm.S
@@ -1514,11 +1514,11 @@ generate_composite_function \
              * output: updated src in   {d0,  d1,  d2 }       [B, G, R]

              *         updated mask in  {d24, d25, d26}       [B, G, R]

              */

-            vmull.u8    q1,  d25, d9

+            vmull.u8    q6,  d26, d10

         vqadd.u8    q8,  q0, q8

             vmull.u8    q0,  d24, d8

         vqadd.u8    d22, d2, d22

-            vmull.u8    q6,  d26, d10

+            vmull.u8    q1,  d25, d9

         /*

          * convert the result in d16, d17, d22 to r5g6b5 and store

          * it into {d28, d29}

@@ -1541,6 +1541,7 @@ generate_composite_function \
             vrshr.u16   q11, q12, #8

             vrshr.u16   q8,  q9,  #8

             vrshr.u16   q6,  q13, #8

+            vraddhn.u16 d24, q12, q11

             vraddhn.u16 d25, q9,  q8

                 /*

                  * convert 8 r5g6b5 pixel data from {d4, d5} to planar

@@ -1549,11 +1550,10 @@ generate_composite_function \
                  */

                 vshrn.u16   d17, q2,  #3

                 vshrn.u16   d18, q2,  #8

-            vraddhn.u16 d24, q12, q11

             vraddhn.u16 d26, q13, q6

                 vsli.u16    q2,  q2,  #5

-                vsri.u8     d18, d18, #5

                 vsri.u8     d17, d17, #6

+                vsri.u8     d18, d18, #5

             /*

              * 'combine_over_ca' replacement

              *

diff --git a/pixman/test/blitters-test.c b/pixman/test/blitters-test.c
index 5b9180f66..ba81fc71a 100644
--- a/pixman/test/blitters-test.c
+++ b/pixman/test/blitters-test.c
@@ -14,6 +14,11 @@
 static pixman_indexed_t rgb_palette[9];

 static pixman_indexed_t y_palette[9];

 

+/* The first eight format in the list are by far the most widely

+ * used formats, so we test those more than the others

+ */

+#define N_MOST_LIKELY_FORMATS 8

+

 /* Create random image for testing purposes */

 static pixman_image_t *

 create_random_image (pixman_format_code_t *allowed_formats,

@@ -29,6 +34,9 @@ create_random_image (pixman_format_code_t *allowed_formats,
 

     while (allowed_formats[n] != PIXMAN_null)

 	n++;

+

+    if (n > N_MOST_LIKELY_FORMATS && lcg_rand_n (4) != 0)

+	n = N_MOST_LIKELY_FORMATS;

     fmt = allowed_formats[lcg_rand_n (n)];

 

     width = lcg_rand_n (max_width) + 1;

@@ -177,12 +185,14 @@ static pixman_op_t op_list[] = {
 

 static pixman_format_code_t img_fmt_list[] = {

     PIXMAN_a8r8g8b8,

+    PIXMAN_a8b8g8r8,

     PIXMAN_x8r8g8b8,

+    PIXMAN_x8b8g8r8,

     PIXMAN_r5g6b5,

-    PIXMAN_r3g3b2,

+    PIXMAN_b5g6r5,

     PIXMAN_a8,

-    PIXMAN_a8b8g8r8,

-    PIXMAN_x8b8g8r8,

+    PIXMAN_a1,

+    PIXMAN_r3g3b2,

     PIXMAN_b8g8r8a8,

     PIXMAN_b8g8r8x8,

     PIXMAN_r8g8b8a8,

@@ -190,8 +200,6 @@ static pixman_format_code_t img_fmt_list[] = {
     PIXMAN_x14r6g6b6,

     PIXMAN_r8g8b8,

     PIXMAN_b8g8r8,

-    PIXMAN_r5g6b5,

-    PIXMAN_b5g6r5,

     PIXMAN_x2r10g10b10,

     PIXMAN_a2r10g10b10,

     PIXMAN_x2b10g10r10,

@@ -204,7 +212,6 @@ static pixman_format_code_t img_fmt_list[] = {
     PIXMAN_x4r4g4b4,

     PIXMAN_a4b4g4r4,

     PIXMAN_x4b4g4r4,

-    PIXMAN_a8,

     PIXMAN_r3g3b2,

     PIXMAN_b2g3r3,

     PIXMAN_a2r2g2b2,

@@ -222,7 +229,6 @@ static pixman_format_code_t img_fmt_list[] = {
     PIXMAN_b1g2r1,

     PIXMAN_a1r1g1b1,

     PIXMAN_a1b1g1r1,

-    PIXMAN_a1,

     PIXMAN_null

 };

 

@@ -417,6 +423,6 @@ main (int argc, const char *argv[])
     }

 

     return fuzzer_test_main("blitters", 2000000,

-			    0x265CDFEB,

+			    0xB610300B,

 			    test_composite, argc, argv);

 }