xgl: Add IMAGE_LAYOUT to Cmd*Image* calls

This is part 2 of bug #12904.
(2) Blit operations need to know what layout images are in. How do they figure that out?

- Added new parameter(s) specifying the image layout(s) to the following functions:
    xglCmdCopyImage
    xglCmdCopyBufferToImage
    xglCmdCopyImageToBuffer
    xglCmdClearColorImage
    xglCmdClearColorImageRaw
    xglCmdClearDepthStencilImage
    xglCmdResolveImage

diff --git a/demos/cube.c b/demos/cube.c
index 84728d0..11041ac 100644 (file)
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -350,10 +350,12 @@ static void demo_draw_build_cmd(struct demo *demo, XGL_CMD_BUFFER cmd_buf)
     clear_range.arraySize = 1;
     xglCmdClearColorImage(cmd_buf,
             demo->buffers[demo->current_buffer].image,
+            XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
             clear_color, 1, &clear_range);
 
     clear_range.aspect = XGL_IMAGE_ASPECT_DEPTH;
     xglCmdClearDepthStencil(cmd_buf, demo->depth.image,
+            XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
             clear_depth, 0, 1, &clear_range);
 
     xglCmdDraw(cmd_buf, 0, 12 * 3, 0, 1);
@@ -929,7 +931,12 @@ static void demo_prepare_textures(struct demo *demo)
                 .destOffset = { 0, 0, 0 },
                 .extent = { staging_texture.tex_width, staging_texture.tex_height, 1 },
             };
-            xglCmdCopyImage(staging_cmd_buf, staging_texture.image, demo->textures[i].image, 1, &copy_region);
+            xglCmdCopyImage(staging_cmd_buf,
+                            staging_texture.image,
+                            XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
+                            demo->textures[i].image,
+                            XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
+                            1, &copy_region);
 
             XGL_IMAGE_MEMORY_BARRIER image_memory_barrier = {
                 .sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,

diff --git a/demos/tri.c b/demos/tri.c
index 086de98..5e5dfb0 100644 (file)
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -182,10 +182,12 @@ static void demo_draw_build_cmd(struct demo *demo)
     clear_range.arraySize = 1;
     xglCmdClearColorImage(demo->cmd,
             demo->buffers[demo->current_buffer].image,
+            XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
             clear_color, 1, &clear_range);
 
     clear_range.aspect = XGL_IMAGE_ASPECT_DEPTH;
-    xglCmdClearDepthStencil(demo->cmd, demo->depth.image,
+    xglCmdClearDepthStencil(demo->cmd,
+            demo->depth.image, XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL,
             clear_depth, 0, 1, &clear_range);
 
     xglCmdDraw(demo->cmd, 0, 3, 0, 1);
@@ -575,7 +577,10 @@ static void demo_prepare_textures(struct demo *demo)
                 .destOffset = { 0, 0, 0 },
                 .extent = { staging_texture.tex_width, staging_texture.tex_height, 1 },
             };
-            xglCmdCopyImage(staging_cmd_buf, staging_texture.image, demo->textures[i].image, 1, &copy_region);
+            xglCmdCopyImage(staging_cmd_buf,
+                            staging_texture.image, XGL_IMAGE_LAYOUT_GENERAL,
+                            demo->textures[i].image, XGL_IMAGE_LAYOUT_GENERAL,
+                            1, &copy_region);
 
             XGL_IMAGE_MEMORY_BARRIER image_memory_barrier = {
                 .sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,

diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 47fa21e..33cff85 100644 (file)
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -908,7 +908,9 @@ ICD_EXPORT void XGLAPI xglCmdCopyBuffer(
 ICD_EXPORT void XGLAPI xglCmdCopyImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
+    XGL_IMAGE_LAYOUT                            srcImageLayout,
     XGL_IMAGE                                   destImage,
+    XGL_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
     const XGL_IMAGE_COPY*                       pRegions)
 {
@@ -918,9 +920,9 @@ ICD_EXPORT void XGLAPI xglCmdCopyImage(
 ICD_EXPORT void XGLAPI xglCmdBlitImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
-    XGL_IMAGE_LAYOUT                            srcLayout,
+    XGL_IMAGE_LAYOUT                            srcImageLayout,
     XGL_IMAGE                                   destImage,
-    XGL_IMAGE_LAYOUT                            destLayout,
+    XGL_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
     const XGL_IMAGE_BLIT*                       pRegions)
 {
@@ -931,6 +933,7 @@ ICD_EXPORT void XGLAPI xglCmdCopyBufferToImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_BUFFER                                  srcBuffer,
     XGL_IMAGE                                   destImage,
+    XGL_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
     const XGL_BUFFER_IMAGE_COPY*                pRegions)
 {
@@ -940,6 +943,7 @@ ICD_EXPORT void XGLAPI xglCmdCopyBufferToImage(
 ICD_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
+    XGL_IMAGE_LAYOUT                            srcImageLayout,
     XGL_BUFFER                                  destBuffer,
     uint32_t                                    regionCount,
     const XGL_BUFFER_IMAGE_COPY*                pRegions)
@@ -980,6 +984,7 @@ ICD_EXPORT void XGLAPI xglCmdFillBuffer(
 ICD_EXPORT void XGLAPI xglCmdClearColorImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   image,
+    XGL_IMAGE_LAYOUT                            imageLayout,
     XGL_CLEAR_COLOR                             color,
     uint32_t                                    rangeCount,
     const XGL_IMAGE_SUBRESOURCE_RANGE*          pRanges)
@@ -990,6 +995,7 @@ ICD_EXPORT void XGLAPI xglCmdClearColorImage(
 ICD_EXPORT void XGLAPI xglCmdClearDepthStencil(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   image,
+    XGL_IMAGE_LAYOUT                            imageLayout,
     float                                       depth,
     uint32_t                                    stencil,
     uint32_t                                    rangeCount,
@@ -1001,7 +1007,9 @@ ICD_EXPORT void XGLAPI xglCmdClearDepthStencil(
 ICD_EXPORT void XGLAPI xglCmdResolveImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
+    XGL_IMAGE_LAYOUT                            srcImageLayout,
     XGL_IMAGE                                   destImage,
+    XGL_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    rectCount,
     const XGL_IMAGE_RESOLVE*                    pRects)
 {

diff --git a/include/xgl.h b/include/xgl.h
index 937575d..dd12fc3 100644 (file)
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -33,7 +33,7 @@
 #include "xglPlatform.h"
 
 // XGL API version supported by this file
-#define XGL_API_VERSION XGL_MAKE_VERSION(0, 59, 2)
+#define XGL_API_VERSION XGL_MAKE_VERSION(0, 59, 0)
 
 #ifdef __cplusplus
 extern "C"
@@ -2333,16 +2333,16 @@ typedef void       (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuf
 typedef void       (XGLAPI *xglCmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
 typedef void       (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset);
 typedef void       (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_COPY* pRegions);
-typedef void       (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions);
-typedef void       (XGLAPI *xglCmdBlitImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destLayout, uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions);
-typedef void       (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
-typedef void       (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
+typedef void       (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions);
+typedef void       (XGLAPI *xglCmdBlitImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions);
+typedef void       (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
+typedef void       (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
 typedef void       (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout);
 typedef void       (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const uint32_t* pData);
 typedef void       (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, uint32_t data);
-typedef void       (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-typedef void       (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
-typedef void       (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects);
+typedef void       (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef void       (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
+typedef void       (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects);
 typedef void       (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent);
 typedef void       (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent);
 typedef void       (XGLAPI *xglCmdWaitEventsType)(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo);
@@ -2864,16 +2864,18 @@ void XGLAPI xglCmdCopyBuffer(
 void XGLAPI xglCmdCopyImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
+    XGL_IMAGE_LAYOUT                            srcImageLayout,
     XGL_IMAGE                                   destImage,
+    XGL_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
     const XGL_IMAGE_COPY*                       pRegions);
 
 void XGLAPI xglCmdBlitImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
-    XGL_IMAGE_LAYOUT                            srcLayout,
+    XGL_IMAGE_LAYOUT                            srcImageLayout,
     XGL_IMAGE                                   destImage,
-    XGL_IMAGE_LAYOUT                            destLayout,
+    XGL_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
     const XGL_IMAGE_BLIT*                       pRegions);
 
@@ -2881,12 +2883,14 @@ void XGLAPI xglCmdCopyBufferToImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_BUFFER                                  srcBuffer,
     XGL_IMAGE                                   destImage,
+    XGL_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    regionCount,
     const XGL_BUFFER_IMAGE_COPY*                pRegions);
 
 void XGLAPI xglCmdCopyImageToBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
+    XGL_IMAGE_LAYOUT                            srcImageLayout,
     XGL_BUFFER                                  destBuffer,
     uint32_t                                    regionCount,
     const XGL_BUFFER_IMAGE_COPY*                pRegions);
@@ -2915,6 +2919,7 @@ void XGLAPI xglCmdFillBuffer(
 void XGLAPI xglCmdClearColorImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   image,
+    XGL_IMAGE_LAYOUT                            imageLayout,
     XGL_CLEAR_COLOR                             color,
     uint32_t                                    rangeCount,
     const XGL_IMAGE_SUBRESOURCE_RANGE*          pRanges);
@@ -2922,6 +2927,7 @@ void XGLAPI xglCmdClearColorImage(
 void XGLAPI xglCmdClearDepthStencil(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   image,
+    XGL_IMAGE_LAYOUT                            imageLayout,
     float                                       depth,
     uint32_t                                    stencil,
     uint32_t                                    rangeCount,
@@ -2930,7 +2936,9 @@ void XGLAPI xglCmdClearDepthStencil(
 void XGLAPI xglCmdResolveImage(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
+    XGL_IMAGE_LAYOUT                            srcImageLayout,
     XGL_IMAGE                                   destImage,
+    XGL_IMAGE_LAYOUT                            destImageLayout,
     uint32_t                                    rectCount,
     const XGL_IMAGE_RESOLVE*                    pRects);
 

diff --git a/layers/draw_state.c b/layers/draw_state.c
index 43080dc..c764412 100644 (file)
--- a/layers/draw_state.c
+++ b/layers/draw_state.c
@@ -2325,7 +2325,12 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFF
     nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer,
+                                             XGL_IMAGE srcImage,
+                                             XGL_IMAGE_LAYOUT srcImageLayout,
+                                             XGL_IMAGE destImage,
+                                             XGL_IMAGE_LAYOUT destImageLayout,
+                                             uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2337,11 +2342,12 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdCopyImage(cmdBuffer, srcImage, destImage, regionCount, pRegions);
+    nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcLayout,
-                                             XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destLayout,
+XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer,
+                                             XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
+                                             XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
                                              uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
@@ -2354,10 +2360,13 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdBlitImage(cmdBuffer, srcImage, srcLayout, destImage, destLayout, regionCount, pRegions);
+    nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer,
+                                                     XGL_BUFFER srcBuffer,
+                                                     XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
+                                                     uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2369,10 +2378,13 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer, X
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, regionCount, pRegions);
+    nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer,
+                                                     XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
+                                                     XGL_BUFFER destBuffer,
+                                                     uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2384,7 +2396,7 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer, X
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, destBuffer, regionCount, pRegions);
+    nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
 }
 
 XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout)
@@ -2432,7 +2444,10 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFF
     nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer,
+                                                   XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
+                                                   XGL_CLEAR_COLOR color,
+                                                   uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2444,10 +2459,13 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdClearColorImage(cmdBuffer, image, color, rangeCount, pRanges);
+    nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer,
+                                                     XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
+                                                     float depth, uint32_t stencil,
+                                                     uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2459,10 +2477,13 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, X
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdClearDepthStencil(cmdBuffer, image, depth, stencil, rangeCount, pRanges);
+    nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer,
+                                                XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
+                                                XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
+                                                uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
@@ -2474,7 +2495,7 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IM
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdResolveImage(cmdBuffer, srcImage, destImage, rectCount, pRects);
+    nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
 }
 
 XGL_LAYER_EXPORT void XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_PIPE_EVENT pipeEvent)

diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 768c60b..72fae40 100644 (file)
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1466,22 +1466,28 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFF
     nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage,
-    uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
+XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImage(XGL_CMD_BUFFER cmdBuffer,
+                                             XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
+                                             XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
+                                             uint32_t regionCount, const XGL_IMAGE_COPY* pRegions)
 {
     // TODO : Each image will have mem mapping so track them
-    nextTable.CmdCopyImage(cmdBuffer, srcImage, destImage, regionCount, pRegions);
+    nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcLayout,
-                                             XGL_IMAGE destImage, uint32_t regionCount, XGL_IMAGE_LAYOUT destLayout,
-                                             const XGL_IMAGE_BLIT* pRegions)
+XGL_LAYER_EXPORT void XGLAPI xglCmdBlitImage(XGL_CMD_BUFFER cmdBuffer,
+                                             XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
+                                             XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
+                                             uint32_t regionCount, const XGL_IMAGE_BLIT* pRegions)
 {
     // TODO : Each image will have mem mapping so track them
-    nextTable.CmdBlitImage(cmdBuffer, srcImage, srcLayout, destImage, destLayout, regionCount, pRegions);
+    nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer,
+                                                     XGL_BUFFER srcBuffer,
+                                                     XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
+                                                     uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
 {
     // TODO : Track this
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1499,11 +1505,13 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdCopyBufferToImage(XGL_CMD_BUFFER cmdBuffer, X
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, regionCount, pRegions);
+    nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer,
-    uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
+XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer,
+                                                     XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
+                                                     XGL_BUFFER destBuffer,
+                                                     uint32_t regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions)
 {
     // TODO : Track this
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1520,7 +1528,7 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdCopyImageToBuffer(XGL_CMD_BUFFER cmdBuffer, X
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, destBuffer, regionCount, pRegions);
+    nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
 }
 
 XGL_LAYER_EXPORT void XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
@@ -1570,7 +1578,10 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdFillBuffer(XGL_CMD_BUFFER cmdBuffer, XGL_BUFF
     nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_CLEAR_COLOR color, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer,
+                                                   XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
+                                                   XGL_CLEAR_COLOR color,
+                                                   uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1581,10 +1592,13 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdClearColorImage(XGL_CMD_BUFFER cmdBuffer, XGL
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdClearColorImage(cmdBuffer, image, color, rangeCount, pRanges);
+    nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, color, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, float depth, uint32_t stencil, uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer,
+                                                     XGL_IMAGE image, XGL_IMAGE_LAYOUT imageLayout,
+                                                     float depth, uint32_t stencil,
+                                                     uint32_t rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
 {
     // TODO : Verify memory is in XGL_IMAGE_STATE_CLEAR state
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1595,11 +1609,13 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdClearDepthStencil(XGL_CMD_BUFFER cmdBuffer, X
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdClearDepthStencil(cmdBuffer, image, depth, stencil, rangeCount, pRanges);
+    nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage,
-    uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
+XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer,
+                                                XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout,
+                                                XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout,
+                                                uint32_t rectCount, const XGL_IMAGE_RESOLVE* pRects)
 {
     loader_platform_thread_lock_mutex(&globalLock);
     XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage);
@@ -1615,7 +1631,7 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XGL_IM
         layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdResolveImage(cmdBuffer, srcImage, destImage, rectCount, pRects);
+    nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, rectCount, pRects);
 }
 
 XGL_LAYER_EXPORT void XGLAPI xglCmdBeginQuery(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, uint32_t slot, XGL_FLAGS flags)

diff --git a/xgl.py b/xgl.py
index da56c20..1da38e6 100644 (file)
--- a/xgl.py
+++ b/xgl.py
@@ -672,16 +672,18 @@ core = Extension(
         Proto("void", "CmdCopyImage",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_IMAGE", "srcImage"),
+             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
              Param("XGL_IMAGE", "destImage"),
+             Param("XGL_IMAGE_LAYOUT", "destImageLayout"),
              Param("uint32_t", "regionCount"),
              Param("const XGL_IMAGE_COPY*", "pRegions")]),
 
         Proto("void", "CmdBlitImage",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_IMAGE", "srcImage"),
-             Param("XGL_IMAGE_LAYOUT", "srcLayout"),
+             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
              Param("XGL_IMAGE", "destImage"),
-             Param("XGL_IMAGE_LAYOUT", "destLayout"),
+             Param("XGL_IMAGE_LAYOUT", "destImageLayout"),
              Param("uint32_t", "regionCount"),
              Param("const XGL_IMAGE_BLIT*", "pRegions")]),
 
@@ -689,12 +691,14 @@ core = Extension(
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_BUFFER", "srcBuffer"),
              Param("XGL_IMAGE", "destImage"),
+             Param("XGL_IMAGE_LAYOUT", "destImageLayout"),
              Param("uint32_t", "regionCount"),
              Param("const XGL_BUFFER_IMAGE_COPY*", "pRegions")]),
 
         Proto("void", "CmdCopyImageToBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_IMAGE", "srcImage"),
+             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
              Param("XGL_BUFFER", "destBuffer"),
              Param("uint32_t", "regionCount"),
              Param("const XGL_BUFFER_IMAGE_COPY*", "pRegions")]),
@@ -723,6 +727,7 @@ core = Extension(
         Proto("void", "CmdClearColorImage",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_IMAGE", "image"),
+             Param("XGL_IMAGE_LAYOUT", "imageLayout"),
             Param("XGL_CLEAR_COLOR", "color"),
              Param("uint32_t", "rangeCount"),
              Param("const XGL_IMAGE_SUBRESOURCE_RANGE*", "pRanges")]),
@@ -730,6 +735,7 @@ core = Extension(
         Proto("void", "CmdClearDepthStencil",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_IMAGE", "image"),
+             Param("XGL_IMAGE_LAYOUT", "imageLayout"),
              Param("float", "depth"),
              Param("uint32_t", "stencil"),
              Param("uint32_t", "rangeCount"),
@@ -738,7 +744,9 @@ core = Extension(
         Proto("void", "CmdResolveImage",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_IMAGE", "srcImage"),
+             Param("XGL_IMAGE_LAYOUT", "srcImageLayout"),
              Param("XGL_IMAGE", "destImage"),
+             Param("XGL_IMAGE_LAYOUT", "destImageLayout"),
              Param("uint32_t", "rectCount"),
              Param("const XGL_IMAGE_RESOLVE*", "pRects")]),