Planar Surface Redescription and pitch adjustment. (#31)

johnmach · web-flow · commit 73fbd5044161 · 2021-03-08T17:47:23.000+05:30
diff --git a/Source/GmmLib/Resource/GmmResourceInfoCommon.cpp b/Source/GmmLib/Resource/GmmResourceInfoCommon.cpp
@@ -1231,6 +1231,12 @@ uint32_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetQPitch()
 /////////////////////////////////////////////////////////////////////////////////////
 GMM_STATUS GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetOffset(GMM_REQ_OFFSET_INFO &ReqInfo)
 {
+    GMM_TEXTURE_CALC *pTextureCalc;
+
+    pTextureCalc = GMM_OVERRIDE_TEXTURE_CALC(&Surf);
+
+    __GMM_ASSERT((pTextureCalc != NULL))
+
     if(Surf.Flags.Info.RedecribedPlanes)
     {
         uint8_t RestoreReqStdLayout = ReqInfo.ReqStdLayout ? 1 : 0;
@@ -1246,6 +1252,7 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetOffset(GMM_REQ_OFFSET_I
         if(ReqInfo.ReqStdLayout)
         {
             GMM_REQ_OFFSET_INFO TempReqInfo[GMM_MAX_PLANE] = {0};
+	    GMM_TEXTURE_INFO    TexInfo[GMM_MAX_PLANE];
             uint32_t            Plane, TotalPlanes = GmmLib::Utility::GmmGetNumPlanes(Surf.Format);
 
             // Caller must specify which plane they need the offset into if not
@@ -1262,11 +1269,15 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetOffset(GMM_REQ_OFFSET_I
             TempReqInfo[GMM_PLANE_Y].ReqLock = TempReqInfo[GMM_PLANE_Y].ReqRender = 0;
 
             TempReqInfo[GMM_PLANE_V] = TempReqInfo[GMM_PLANE_U] = TempReqInfo[GMM_PLANE_Y];
-
-            if(GMM_SUCCESS != GmmTexGetMipMapOffset(&PlaneSurf[GMM_PLANE_Y], &TempReqInfo[GMM_PLANE_Y]) ||
-               GMM_SUCCESS != GmmTexGetMipMapOffset(&PlaneSurf[GMM_PLANE_U], &TempReqInfo[GMM_PLANE_U]) ||
-               GMM_SUCCESS != GmmTexGetMipMapOffset(&PlaneSurf[GMM_PLANE_V], &TempReqInfo[GMM_PLANE_V]))
-            {
+            
+	    pTextureCalc->GetRedescribedPlaneParams(&Surf, GMM_PLANE_Y, &TexInfo[GMM_PLANE_Y]);
+            pTextureCalc->GetRedescribedPlaneParams(&Surf, GMM_PLANE_U, &TexInfo[GMM_PLANE_U]);
+            pTextureCalc->GetRedescribedPlaneParams(&Surf, GMM_PLANE_V, &TexInfo[GMM_PLANE_V]);
+
+            if(GMM_SUCCESS != GmmTexGetMipMapOffset(&TexInfo[GMM_PLANE_Y], &TempReqInfo[GMM_PLANE_Y]) ||
+               GMM_SUCCESS != GmmTexGetMipMapOffset(&TexInfo[GMM_PLANE_U], &TempReqInfo[GMM_PLANE_U]) ||
+               GMM_SUCCESS != GmmTexGetMipMapOffset(&TexInfo[GMM_PLANE_V], &TempReqInfo[GMM_PLANE_V]))
+	    {
                 __GMM_ASSERT(0);
                 return GMM_ERROR;
             }
@@ -1295,9 +1306,10 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetOffset(GMM_REQ_OFFSET_I
                 {
                     // Find the size of the previous planes and add it to the offset
                     TempReqInfo[Plane].StdLayout.Offset = -1;
-
-                    if(GMM_SUCCESS != GmmTexGetMipMapOffset(&PlaneSurf[Plane], &TempReqInfo[Plane]))
+                
+		    if(GMM_SUCCESS != GmmTexGetMipMapOffset(&TexInfo[Plane], &TempReqInfo[Plane]))
                     {
+                 
                         __GMM_ASSERT(0);
                         return GMM_ERROR;
                     }
@@ -1336,6 +1348,7 @@ uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::CpuBlt(GMM_RES_COPY_BLT *pBlt
     uint8_t                  Success = 1;
     GMM_TEXTURE_INFO *       pTexInfo;
     GMM_TEXTURE_CALC *       pTextureCalc;
+    GMM_TEXTURE_INFO         RedescribedPlaneInfo;
 
     __GMM_ASSERTPTR(pBlt, 0);
 
@@ -1468,13 +1481,15 @@ uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::CpuBlt(GMM_RES_COPY_BLT *pBlt
 
         if(pBlt->Gpu.OffsetY < pTexInfo->OffsetInfo.Plane.Y[GMM_PLANE_U])
         {
+	    pTextureCalc->GetRedescribedPlaneParams(pTexInfo, GMM_PLANE_Y, &RedescribedPlaneInfo);
             // Y Plane
-            pTexInfo = &(PlaneSurf[GMM_PLANE_Y]);
+            pTexInfo = &RedescribedPlaneInfo;
         }
         else
         {
             // UV Plane
-            pTexInfo = &(PlaneSurf[GMM_PLANE_U]);
+	    pTextureCalc->GetRedescribedPlaneParams(pTexInfo, GMM_PLANE_U, &RedescribedPlaneInfo);
+            pTexInfo = &RedescribedPlaneInfo;
         }
     }
 
@@ -1869,12 +1884,14 @@ uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetMappingSpanDesc(GMM_GET_MA
     uint8_t                  WasFinalSpan = 0;
     GMM_TEXTURE_INFO *       pTexInfo;
     GMM_TEXTURE_CALC *       pTextureCalc;
+    GMM_TEXTURE_INFO         RedescribedPlaneInfo;
 
     __GMM_ASSERT(Surf.Flags.Info.StdSwizzle);
 
     pPlatform    = GMM_OVERRIDE_PLATFORM_INFO(&Surf);
     pTextureCalc = GMM_OVERRIDE_TEXTURE_CALC(&Surf);
 
+    __GMM_ASSERT(pTextureCalc != NULL);
     pTexInfo = &Surf;
 
     if(pMapping->Type == GMM_MAPPING_GEN9_YS_TO_STDSWIZZLE)
@@ -1933,7 +1950,9 @@ uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetMappingSpanDesc(GMM_GET_MA
                 pMapping->__NextSpan.VirtualOffset  = ReqInfo.Render.Offset64;
             }
 
-            pTexInfo = &PlaneSurf[pMapping->Scratch.Plane];
+	    pTextureCalc->GetRedescribedPlaneParams(pTexInfo, GMM_PLANE_Y, &RedescribedPlaneInfo);
+            pTexInfo = &RedescribedPlaneInfo;
+
         }
 
         // Initialization of Mapping Params...
diff --git a/Source/GmmLib/Texture/GmmGen10Texture.cpp b/Source/GmmLib/Texture/GmmGen10Texture.cpp
@@ -898,6 +898,14 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmGen10TextureCalc::FillTexPlanar(GMM_TEXTURE_IN
             pTexInfo->Flags.Gpu.MMC = 0;
         }
     }
+    
+    if(pTexInfo->Flags.Info.RedecribedPlanes)
+    {
+        if(false == RedescribeTexturePlanes(pTexInfo, &WidthBytesPhysical))
+        {
+            __GMM_ASSERT(FALSE);
+        }
+    }
 
     if((Status = // <-- Note assignment.
         FillTexPitchAndSize(
diff --git a/Source/GmmLib/Texture/GmmGen11Texture.cpp b/Source/GmmLib/Texture/GmmGen11Texture.cpp
@@ -1086,6 +1086,14 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmGen11TextureCalc::FillTexPlanar(GMM_TEXTURE_IN
         }
     }
 
+    if(pTexInfo->Flags.Info.RedecribedPlanes)
+    {
+        if(false == RedescribeTexturePlanes(pTexInfo, &WidthBytesPhysical))
+        {
+            __GMM_ASSERT(FALSE);
+        }
+    }
+
     if((Status = // <-- Note assignment.
         FillTexPitchAndSize(
         pTexInfo, WidthBytesPhysical, Height, pRestrictions)) == GMM_SUCCESS)
diff --git a/Source/GmmLib/Texture/GmmGen12Texture.cpp b/Source/GmmLib/Texture/GmmGen12Texture.cpp
@@ -923,7 +923,15 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmGen12TextureCalc::FillTexPlanar(GMM_TEXTURE_IN
 
         Height = YHeight + VHeight;
     }
-
+    
+    if(pTexInfo->Flags.Info.RedecribedPlanes)
+    {
+        if(false == RedescribeTexturePlanes(pTexInfo, &WidthBytesPhysical))
+        {
+            __GMM_ASSERT(FALSE);
+        }
+    }
+    
     if((Status = // <-- Note assignment.
         FillTexPitchAndSize(
         pTexInfo, WidthBytesPhysical, Height, pRestrictions)) == GMM_SUCCESS)
diff --git a/Source/GmmLib/Texture/GmmTexture.cpp b/Source/GmmLib/Texture/GmmTexture.cpp
@@ -629,3 +629,200 @@ bool GmmLib::GmmTextureCalc::GmmGetD3DToHwTileConversion(GMM_TEXTURE_INFO *pTexI
     *pRowFactor = 0;
     return false;
 }
+
+/////////////////////////////////////////////////////////////////////////////////////
+/// This function redescribes WidthBytesPhysical of main surface as per UV plane bpp and tilemode
+///
+/// @return     ::bool
+/////////////////////////////////////////////////////////////////////////////////////
+bool GmmLib::GmmTextureCalc::RedescribeTexturePlanes(GMM_TEXTURE_INFO *pTexInfo, uint32_t *pWidthBytesPhysical)
+{
+    GMM_STATUS               Status = GMM_SUCCESS;
+    GMM_TEXTURE_INFO         TexInfoUVPlane;
+    const GMM_PLATFORM_INFO *pPlatform = GMM_OVERRIDE_PLATFORM_INFO(pTexInfo);
+
+    __GMM_ASSERT(pTexInfo);
+    __GMM_ASSERT(pTexInfo->Flags.Info.RedecribedPlanes);
+    __GMM_ASSERT(pWidthBytesPhysical);
+
+    TexInfoUVPlane = *pTexInfo;
+#ifdef _WIN32
+    memcpy_s(&TexInfoUVPlane, sizeof(GMM_TEXTURE_INFO), pTexInfo, sizeof(GMM_TEXTURE_INFO));
+#else
+    memcpy(&TexInfoUVPlane, pTexInfo, sizeof(GMM_TEXTURE_INFO));
+#endif // _WIN32
+
+
+    if(GmmIsUVPacked(pTexInfo->Format))
+    {
+        // UV packed resources must have two seperate
+        // tiling modes per plane, due to the packed
+        // UV plane having twice the bits per pixel
+        // as the Y plane.
+        switch(pTexInfo->Format)
+        {
+            case GMM_FORMAT_NV12:
+            case GMM_FORMAT_NV21:
+            case GMM_FORMAT_P208:
+                TexInfoUVPlane.BitsPerPixel = 16; // Redescribe bpp to 16 from 8
+                break;
+            case GMM_FORMAT_P010:
+            case GMM_FORMAT_P012:
+            case GMM_FORMAT_P016:
+            case GMM_FORMAT_P216:
+                TexInfoUVPlane.BitsPerPixel = 32;
+                break;
+            default:
+                GMM_ASSERTDPF(0, "Unsupported format/pixel size combo!");
+                Status = GMM_INVALIDPARAM;
+                goto ERROR_CASE;
+                break;
+        }
+    }
+    else
+    {
+        // Non-UV packed surfaces, TileMode and bpp of each plane is same as that of pTexInfo
+    }
+
+    SetTileMode(&TexInfoUVPlane);
+    *pWidthBytesPhysical = GFX_ALIGN(*pWidthBytesPhysical, pPlatform->TileInfo[TexInfoUVPlane.TileMode].LogicalTileWidth);
+
+ERROR_CASE:
+    return (Status == GMM_SUCCESS) ? true : false;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+/// This function returns per plane redescribed parameters (pRedescribedTexInfo: fmt, tilemode,bpp, width, height, size) when main surface pTexInfo is passed
+///
+/// @return     ::bool
+/////////////////////////////////////////////////////////////////////////////////////
+bool GmmLib::GmmTextureCalc::GetRedescribedPlaneParams(GMM_TEXTURE_INFO *pTexInfo, GMM_YUV_PLANE PlaneType, GMM_TEXTURE_INFO *pRedescribedTexInfo)
+{
+    GMM_STATUS               Status = GMM_SUCCESS;
+    GMM_TEXTURE_INFO         TexInfoUVPlane;
+    const GMM_PLATFORM_INFO *pPlatform = GMM_OVERRIDE_PLATFORM_INFO(pTexInfo);
+
+    __GMM_ASSERT(pTexInfo);
+    __GMM_ASSERT(pTexInfo->Flags.Info.RedecribedPlanes);
+    __GMM_ASSERT(pRedescribedTexInfo);
+
+    *pRedescribedTexInfo                             = *pTexInfo;
+    pRedescribedTexInfo->Flags.Info.RedecribedPlanes = 0;
+#ifdef _WIN32
+    memcpy_s(&TexInfoUVPlane, sizeof(GMM_TEXTURE_INFO), pTexInfo, sizeof(GMM_TEXTURE_INFO));
+#else
+    memcpy(&TexInfoUVPlane, pTexInfo, sizeof(GMM_TEXTURE_INFO));
+#endif // _WIN32
+
+    if(GmmIsUVPacked(pTexInfo->Format))
+    {
+        // UV packed resources must have two seperate
+        // tiling modes per plane, due to the packed
+        // UV plane having twice the bits per pixel
+        // as the Y plane.
+        if((PlaneType == GMM_PLANE_U) || (PlaneType == GMM_PLANE_V))
+        {
+            switch(pTexInfo->Format)
+            {
+                // GMM_FORMAT_NV11  :                               linear format, no tiling supported, hence no redescription supported
+                case GMM_FORMAT_NV12:
+                case GMM_FORMAT_NV21:
+                    pRedescribedTexInfo->BitsPerPixel = 16;
+                    pRedescribedTexInfo->BaseWidth    = GFX_CEIL_DIV(pTexInfo->BaseWidth, 2);
+                    pRedescribedTexInfo->BaseHeight   = GFX_CEIL_DIV(pTexInfo->BaseHeight, 2);
+                    break;
+                case GMM_FORMAT_P208:
+                    pRedescribedTexInfo->BitsPerPixel = 16;
+                    pRedescribedTexInfo->BaseWidth    = GFX_CEIL_DIV(pTexInfo->BaseWidth, 2);
+                    // same base height as main surface
+                    break;
+                case GMM_FORMAT_P010:
+                case GMM_FORMAT_P012:
+                case GMM_FORMAT_P016:
+                    pRedescribedTexInfo->BitsPerPixel = 32;
+                    pRedescribedTexInfo->BaseWidth    = GFX_CEIL_DIV(pTexInfo->BaseWidth, 2);
+                    pRedescribedTexInfo->BaseHeight   = GFX_CEIL_DIV(pTexInfo->BaseHeight, 2);
+                    break;
+                case GMM_FORMAT_P216:
+                    pRedescribedTexInfo->BitsPerPixel = 32;
+                    pRedescribedTexInfo->BaseWidth    = GFX_CEIL_DIV(pTexInfo->BaseWidth, 2);
+                    // same base height as main surface
+                    break;
+                default:
+                    GMM_ASSERTDPF(0, "Unsupported format/pixel size combo!");
+                    Status = GMM_INVALIDPARAM;
+                    goto ERROR_CASE;
+                    break;
+            }
+        }
+    }
+    else
+    {
+        // Non-UV packed surfaces TileMode of each plane is same as that of pTexInfo
+        if((PlaneType == GMM_PLANE_U) || (PlaneType == GMM_PLANE_V))
+        { // Non-UV packed surfaces only require the plane descriptors have proper height and width for each plane
+            switch(pTexInfo->Format)
+            {
+                case GMM_FORMAT_IMC1:
+                case GMM_FORMAT_IMC2:
+                case GMM_FORMAT_IMC3:
+                case GMM_FORMAT_IMC4:
+                case GMM_FORMAT_MFX_JPEG_YUV420:
+                    pRedescribedTexInfo->BaseWidth  = GFX_CEIL_DIV(pTexInfo->BaseWidth, 2);
+                    pRedescribedTexInfo->BaseHeight = GFX_CEIL_DIV(pTexInfo->BaseHeight, 2);
+                    break;
+                case GMM_FORMAT_MFX_JPEG_YUV422V:
+                    pRedescribedTexInfo->BaseHeight = GFX_CEIL_DIV(pTexInfo->BaseHeight, 2);
+                    break;
+                case GMM_FORMAT_MFX_JPEG_YUV411R_TYPE:
+                    pRedescribedTexInfo->BaseHeight = GFX_CEIL_DIV(pTexInfo->BaseHeight, 4);
+                    break;
+                case GMM_FORMAT_MFX_JPEG_YUV411:
+                    pRedescribedTexInfo->BaseWidth = GFX_CEIL_DIV(pTexInfo->BaseWidth, 4);
+                    break;
+                case GMM_FORMAT_MFX_JPEG_YUV422H:
+                    pRedescribedTexInfo->BaseWidth = GFX_CEIL_DIV(pTexInfo->BaseWidth, 2);
+                    break;
+                default:
+                    GMM_ASSERTDPF(0, "Unsupported format/pixel size combo!");
+                    Status = GMM_INVALIDPARAM;
+                    goto ERROR_CASE;
+                    break;
+            }
+        }
+    }
+
+    SetTileMode(pRedescribedTexInfo);
+    switch(pRedescribedTexInfo->BitsPerPixel)
+    {
+        case 8:
+            pRedescribedTexInfo->Format = GMM_FORMAT_R8_UINT;
+            break;
+        case 16:
+            pRedescribedTexInfo->Format = GMM_FORMAT_R16_UINT;
+            break;
+        case 32:
+            pRedescribedTexInfo->Format = GMM_FORMAT_R32_UINT;
+            break;
+        default:
+            GMM_ASSERTDPF(0, "Unsupported format/pixel size combo!");
+            Status = GMM_INVALIDPARAM;
+            goto ERROR_CASE;
+            break;
+    }
+    if(pTexInfo->ArraySize > 1)
+    {
+        pRedescribedTexInfo->OffsetInfo.Plane.ArrayQPitch = 0; // no longer a planar format on redescription
+        pRedescribedTexInfo->Alignment.QPitch             = GFX_ALIGN(pRedescribedTexInfo->BaseHeight, pTexInfo->Alignment.VAlign);
+        pRedescribedTexInfo->OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender =
+        pRedescribedTexInfo->OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = pRedescribedTexInfo->Alignment.QPitch * pTexInfo->Pitch;
+        pRedescribedTexInfo->Size                                           = pRedescribedTexInfo->Alignment.QPitch * pTexInfo->Pitch * pTexInfo->ArraySize;
+    }
+    else
+    {
+        pRedescribedTexInfo->Size = (GFX_ALIGN(pRedescribedTexInfo->BaseHeight, pTexInfo->Alignment.VAlign)) * pTexInfo->Pitch;
+    }
+
+ERROR_CASE:
+    return (Status == GMM_SUCCESS) ? true : false;
+}
diff --git a/Source/GmmLib/Texture/GmmTextureAlloc.cpp b/Source/GmmLib/Texture/GmmTextureAlloc.cpp
@@ -1366,6 +1366,14 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmTextureCalc::FillTexPlanar(GMM_TEXTURE_INFO *
         }
     }
 
+    if(pTexInfo->Flags.Info.RedecribedPlanes)
+    {
+        if(false == RedescribeTexturePlanes(pTexInfo, &WidthBytesPhysical))
+        {
+            __GMM_ASSERT(FALSE);
+        }
+    }
+
     if((Status = // <-- Note assignment.
         FillTexPitchAndSize(
         pTexInfo, WidthBytesPhysical, Height, pRestrictions)) == GMM_SUCCESS)
diff --git a/Source/GmmLib/ULT/GmmGen12dGPUResourceULT.cpp b/Source/GmmLib/ULT/GmmGen12dGPUResourceULT.cpp
diff --git a/Source/GmmLib/inc/Internal/Common/Texture/GmmTextureCalc.h b/Source/GmmLib/inc/Internal/Common/Texture/GmmTextureCalc.h

Original file line number	Diff line number	Diff line change
`@@ -898,6 +898,14 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmGen10TextureCalc::FillTexPlanar(GMM_TEXTURE_IN`
`898`	`898`	`pTexInfo->Flags.Gpu.MMC = 0;`
`899`	`899`	`}`
`900`	`900`	`}`
	`901`	`+`
	`902`	`+ if(pTexInfo->Flags.Info.RedecribedPlanes)`
	`903`	`+ {`
	`904`	`+ if(false == RedescribeTexturePlanes(pTexInfo, &WidthBytesPhysical))`
	`905`	`+ {`
	`906`	`+ __GMM_ASSERT(FALSE);`
	`907`	`+ }`
	`908`	`+ }`
`901`	`909`
`902`	`910`	`if((Status = // <-- Note assignment.`
`903`	`911`	`FillTexPitchAndSize(`
Original file line number	Diff line number	Diff line change
`@@ -1086,6 +1086,14 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmGen11TextureCalc::FillTexPlanar(GMM_TEXTURE_IN`
`1086`	`1086`	`}`
`1087`	`1087`	`}`
`1088`	`1088`
	`1089`	`+ if(pTexInfo->Flags.Info.RedecribedPlanes)`
	`1090`	`+ {`
	`1091`	`+ if(false == RedescribeTexturePlanes(pTexInfo, &WidthBytesPhysical))`
	`1092`	`+ {`
	`1093`	`+ __GMM_ASSERT(FALSE);`
	`1094`	`+ }`
	`1095`	`+ }`
	`1096`	`+`
`1089`	`1097`	`if((Status = // <-- Note assignment.`
`1090`	`1098`	`FillTexPitchAndSize(`
`1091`	`1099`	`pTexInfo, WidthBytesPhysical, Height, pRestrictions)) == GMM_SUCCESS)`
Original file line number	Diff line number	Diff line change
`@@ -1366,6 +1366,14 @@ GMM_STATUS GMM_STDCALL GmmLib::GmmTextureCalc::FillTexPlanar(GMM_TEXTURE_INFO *`
`1366`	`1366`	`}`
`1367`	`1367`	`}`
`1368`	`1368`
	`1369`	`+ if(pTexInfo->Flags.Info.RedecribedPlanes)`
	`1370`	`+ {`
	`1371`	`+ if(false == RedescribeTexturePlanes(pTexInfo, &WidthBytesPhysical))`
	`1372`	`+ {`
	`1373`	`+ __GMM_ASSERT(FALSE);`
	`1374`	`+ }`
	`1375`	`+ }`
	`1376`	`+`
`1369`	`1377`	`if((Status = // <-- Note assignment.`
`1370`	`1378`	`FillTexPitchAndSize(`
`1371`	`1379`	`pTexInfo, WidthBytesPhysical, Height, pRestrictions)) == GMM_SUCCESS)`