Update AGS_SDK for 5.0 release

jstewart-amd · jstewart-amd · commit b0383216e4f8 · 2016-12-07T16:20:14.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,9 @@
 
 **Note:** See `ags_lib\CHANGELOG.md` for changes to the core AGS library.
 
+### v5.0.5 - 2016-12-07
+* Update samples for latest AGS API
+
 ### v4.0.3 - 2016-08-18
 * Fix up crossfire_sample for latest AGS API
 
diff --git a/README.md b/README.md
@@ -1,7 +1,7 @@
 # AMD AGS SDK
 ![AMD AGS SDK](http://gpuopen-librariesandsdks.github.io/media/amd_logo_black.png)
 
-The AMD GPU Services (AGS) library provides software developers with the ability to query AMD GPU software and hardware state information that is not normally available through standard operating systems or graphic APIs. Version 4.0 of the library includes support for querying graphics driver version info, GPU performance, Crossfire&trade; (AMD's multi-GPU rendering technology) configuration info, and Eyefinity (AMD's multi-display rendering technology) configuration info. AGS also exposes the explicit Crossfire API extension, GCN shader extensions, and additional extensions supported in the AMD drivers for DirectX 11 and DirectX 12.
+The AMD GPU Services (AGS) library provides software developers with the ability to query AMD GPU software and hardware state information that is not normally available through standard operating systems or graphic APIs. AGS includes support for querying graphics driver version info, GPU performance, Crossfire&trade; (AMD's multi-GPU rendering technology) configuration info, and Eyefinity (AMD's multi-display rendering technology) configuration info. AGS also exposes the explicit Crossfire API extension, GCN shader extensions, and additional extensions supported in the AMD drivers for DirectX 11 and DirectX 12. Version 5.0 adds support for HDR displays.
 
 In addition to the library itself, the AGS SDK includes several samples to demonstrate use of the library.
 
@@ -10,24 +10,26 @@ In addition to the library itself, the AGS SDK includes several samples to demon
 </div>
 
 ### What's new in AGS
-AGS now returns a lot more information from the GPU in addition to exposing the explicit Crossfire API and other extensions for DirectX 11. Version 4.0 also exposes GCN shader extensions for both DirectX 11 and DirectX 12. Highlights include the following:
-
-* The initialization function can now return information about the GPU:
-  * Whether the GPU is GCN or not
-  * The adapter string and device id
-  * The driver version is now rolled into this structure instead of a separate function call
-  * Performance metrics such as the number of compute units and clock speeds
-* New explicit Crossfire API
-  * Provides the ability to control resource transfers between GPUs in Crossfire configuration in DirectX 11
-  * Allows improved performance in multi-GPU configurations
-* New GCN shader extension support
-  * DirectX 11 and DirectX 12
-  * Requires Radeon Software Crimson Edition 16.9.1 (driver version 16.40) or later
-* AGS provides access to additional extensions available in the AMD driver for DirectX 11:
+Version 5.0 is a major overhaul of the library designed to provide a much clearer view of the GPUs in the system and the displays attached to them. It also exposes the ability to query each display for HDR capabilities and put those HDR-capable displays into various HDR modes.
+
+Highlights include the following:
+* Full GPU enumeration with adapter string, device id, revision id and vendor id.
+* Per-GPU display enumeration including information on display name, resolution, and HDR capabilities.
+* Optional user-supplied memory allocator.
+* Function to set displays into HDR mode.
+* DirectX 11 shader compiler controls.
+* DirectX 11 multiview extension.
+* DirectX 11 Crossfire API updates.
+  * Now supports using the API without needing a driver profile.
+  * You can also now specify the transfer engine.
+
+### Driver extensions
+AGS exposes GCN shader extensions for both DirectX 11 and DirectX 12. It also provides access to additional extensions available in the AMD driver for DirectX 11:
   * Quad List primitive type
   * UAV overlap
   * Depth bounds test
   * Multi-draw indirect
+  * Multiview
 
 ### Prerequisites
 * AMD Radeon&trade; GCN-based GPU (HD 7000 series or newer)
diff --git a/ags_sample/src/AGSSample.cpp b/ags_sample/src/AGSSample.cpp
@@ -33,69 +33,104 @@
 #include <amd_ags.h>
 
 
-#pragma warning( disable : 4100 ) // disable unreference formal parameter warnings for /W4 builds
 
-void GetEyefinityInfo( AGSContext* context, int primaryDisplayIndex )
+const char* getVendorName( int vendorId )
 {
-    int numDisplaysInfo = 0;
+    switch ( vendorId )
+    {
+        case 0x1002: return "AMD";
+        case 0x8086: return "INTEL";
+        case 0x10DE: return "NVIDIA";
+        default: return "unknown";
+    }
+}
+
 
-    // Query the number of displays first
-    if ( agsGetEyefinityConfigInfo( context, primaryDisplayIndex, nullptr, &numDisplaysInfo, nullptr ) == AGS_SUCCESS && numDisplaysInfo > 0 )
+void PrintDisplayInfo( const AGSGPUInfo& gpuInfo )
+{
+    for ( int gpuIndex = 0; gpuIndex < gpuInfo.numDevices; gpuIndex++ )
     {
-        AGSEyefinityInfo eyefinityInfo = {};
-        AGSDisplayInfo* displaysInfo = new AGSDisplayInfo[ numDisplaysInfo ];
-        ZeroMemory( displaysInfo, numDisplaysInfo * sizeof( *displaysInfo ) );
+        const AGSDeviceInfo& device = gpuInfo.devices[ gpuIndex ];
+
+        printf( "\n---------- Device %d%s, %s\n", gpuIndex, device.isPrimaryDevice ? " [primary]" : "", device.adapterString );
+
+        printf( "Vendor id:   0x%04X (%s)\n", device.vendorId, getVendorName( device.vendorId ) );
+        printf( "Device id:   0x%04X\n", device.deviceId );
+        printf( "Revision id: 0x%04X\n\n", device.revisionId );
 
-        // Find out if this display has an Eyefinity config enabled
-        if ( agsGetEyefinityConfigInfo( context, primaryDisplayIndex, &eyefinityInfo, &numDisplaysInfo, displaysInfo ) == AGS_SUCCESS )
+        if ( device.vendorId == 0x1002 )
         {
-            if ( eyefinityInfo.iSLSActive )
-            {
-                printf( "Eyefinity enabled for display index %d:\n", primaryDisplayIndex );
-                printf( "  SLS grid is %d displays wide by %d displays tall\n", eyefinityInfo.iSLSGridWidth, eyefinityInfo.iSLSGridHeight );
-                printf( "  SLS resolution is %d x %d pixels\n", eyefinityInfo.iSLSWidth, eyefinityInfo.iSLSHeight );
-
-                if ( eyefinityInfo.iBezelCompensatedDisplay )
-                {
-                    printf( " SLS is bezel-compensated\n" );
-                }
-
-                for ( int i = 0; i < numDisplaysInfo; i++ )
-                {
-                    printf( "Display %d\n", i );
-
-                    if ( displaysInfo[ i ].iPreferredDisplay )
-                    {
-                        printf( " Preferred/main monitor\n" );
-                    }
-
-                    printf( " SLS grid coord [%d,%d]\n", displaysInfo[i].iGridXCoord, displaysInfo[i].iGridYCoord );
-                    printf( " Base coord [%d,%d]\n", displaysInfo[i].displayRect.iXOffset, displaysInfo[i].displayRect.iYOffset );
-                    printf( " Dimensions [%d x %d]\n", displaysInfo[i].displayRect.iWidth, displaysInfo[i].displayRect.iHeight );
-                    printf( " Visible base coord [%d,%d]\n", displaysInfo[i].displayRectVisible.iXOffset, displaysInfo[i].displayRectVisible.iYOffset );
-                    printf( " Visible dimensions [%d x %d]\n", displaysInfo[i].displayRectVisible.iWidth, displaysInfo[i].displayRectVisible.iHeight );
-                }
-            }
-            else
+            printf( "Is %sGCN, %d CUs, core clock %d MHz, memory clock %d MHz, %.1f Tflops\n", device.architectureVersion == AGSDeviceInfo::ArchitectureVersion_GCN ? "" : "not ", device.numCUs, device.coreClock, device.memoryClock, device.teraFlops );
+            printf( "local memory: %d MBs\n\n", (int)( device.localMemoryInBytes / ( 1024 * 1024 ) ) );
+        }
+
+        printf( "\n" );
+
+        if ( device.eyefinityEnabled )
+        {
+            printf( "SLS grid is %d displays wide by %d displays tall\n", device.eyefinityGridWidth, device.eyefinityGridHeight );
+            printf( "SLS resolution is %d x %d pixels\n", device.eyefinityResolutionX, device.eyefinityResolutionY );
+
+            if ( device.eyefinityBezelCompensated )
             {
-                printf( "Eyefinity not enabled for display index %d\n", primaryDisplayIndex );
+                printf( " SLS is bezel-compensated\n" );
             }
         }
         else
         {
-            printf( "Eyefinity configuration query failed to get display info for display index %d\n", primaryDisplayIndex );
+            printf( "Eyefinity not enabled on this device\n" );
         }
 
-        delete[] displaysInfo;
-    }
-    else
-    {
-        printf( "Eyefinity configuration query failed to get number of displays for display index %d\n", primaryDisplayIndex );
+        printf( "\n" );
+
+        for ( int i = 0; i < device.numDisplays; i++ )
+        {
+            const AGSDisplayInfo& display = device.displays[ i ];
+
+            printf( "\t---------- Display %d %s----------------------------------------\n", i, display.displayFlags & AGS_DISPLAYFLAG_PRIMARY_DISPLAY ? "[primary]" : "---------" );
+
+            printf( "\tdevice name: %s\n", display.displayDeviceName );
+            printf( "\tmonitor name: %s\n\n", display.name );
+
+            printf( "\tMax resolution:             %d x %d, %.1f Hz\n", display.maxResolutionX, display.maxResolutionY, display.maxRefreshRate );
+            printf( "\tCurrent resolution:         %d x %d, Offset (%d, %d), %.1f Hz\n", display.currentResolution.width, display.currentResolution.height, display.currentResolution.offsetX, display.currentResolution.offsetY, display.currentRefreshRate );
+            printf( "\tVisible resolution:         %d x %d, Offset (%d, %d)\n\n", display.visibleResolution.width, display.visibleResolution.height, display.visibleResolution.offsetX, display.visibleResolution.offsetY );
+
+            printf( "\tchromaticity red:           %f, %f\n", display.chromaticityRedX, display.chromaticityRedY );
+            printf( "\tchromaticity green:         %f, %f\n", display.chromaticityGreenX, display.chromaticityGreenY );
+            printf( "\tchromaticity blue:          %f, %f\n", display.chromaticityBlueX, display.chromaticityBlueY );
+            printf( "\tchromaticity white point:   %f, %f\n\n", display.chromaticityWhitePointX, display.chromaticityWhitePointY );
+
+            printf( "\tluminance: [min, max, avg]  %f, %f, %f\n", display.minLuminance, display.maxLuminance, display.avgLuminance );
+
+            printf( "\tscreen reflectance diffuse  %f\n", display.screenDiffuseReflectance );
+            printf( "\tscreen reflectance specular %f\n\n", display.screenSpecularReflectance );
+
+            if ( display.displayFlags & AGS_DISPLAYFLAG_HDR10 )
+                printf( "\tHDR10 supported\n" );
+
+            if ( display.displayFlags & AGS_DISPLAYFLAG_DOLBYVISION )
+                printf( "\tDolby Vision supported\n" );
+
+            printf( "\n" );
+
+            if ( display.displayFlags & AGS_DISPLAYFLAG_EYEFINITY_IN_GROUP )
+            {
+                printf( "\tEyefinity Display [%s mode] %s\n", display.displayFlags & AGS_DISPLAYFLAG_EYEFINITY_IN_PORTRAIT_MODE ? "portrait" : "landscape", display.displayFlags & AGS_DISPLAYFLAG_EYEFINITY_PREFERRED_DISPLAY ? " (preferred display)" : "" );
+
+                printf( "\tGrid coord %d x %d\n", display.eyefinityGridCoordX, display.eyefinityGridCoordY );
+            }
+
+            printf( "\tlogical display index: %d\n", display.logicalDisplayIndex );
+            printf( "\tADL adapter index: %d\n\n", display.adlAdapterIndex );
+
+            printf( "\n" );
+        }
     }
 }
 
 
-int main(int argc, char* argv[])
+int main(int , char**)
 {
     // Enable run-time memory check for debug builds.
     // (When _DEBUG is not defined, calls to _CrtSetDbgFlag are removed during preprocessing.)
@@ -104,59 +139,29 @@ int main(int argc, char* argv[])
     AGSContext* agsContext = nullptr;
 
     int displayIndex = 0;
-    int primaryDisplayIndex = 0;
     DISPLAY_DEVICEA displayDevice;
     displayDevice.cb = sizeof( displayDevice );
     while ( EnumDisplayDevicesA( 0, displayIndex, &displayDevice, 0 ) )
     {
-        if ( displayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE )
-        {
-            primaryDisplayIndex = displayIndex;
-        }
-
-        //printf( "Display Device: %d %s %s\n", displayIndex, displayDevice.DeviceString, displayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE ? "(primary)" : "" );
-
+        printf( "Display Device: %d: %s, %s %s%s\n", displayIndex, displayDevice.DeviceString, displayDevice.DeviceName, displayDevice.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE ? "(primary)" : "", displayDevice.StateFlags & DISPLAY_DEVICE_ACTIVE ? "" : " [disabled]" );
         displayIndex++;
     }
 
     AGSGPUInfo gpuInfo;
-    if ( agsInit( &agsContext, nullptr, &gpuInfo ) == AGS_SUCCESS )
+
+    AGSConfiguration config = {};
+    config.crossfireMode = AGS_CROSSFIRE_MODE_EXPLICIT_AFR;
+
+    if ( agsInit( &agsContext, &config, &gpuInfo ) == AGS_SUCCESS )
     {
-        printf( "AGS Library initialized: v%d.%d.%d\n\n", gpuInfo.agsVersionMajor, gpuInfo.agsVersionMinor, gpuInfo.agsVersionPatch );
+        printf( "\nAGS Library initialized: v%d.%d.%d\n", gpuInfo.agsVersionMajor, gpuInfo.agsVersionMinor, gpuInfo.agsVersionPatch );
+        printf( "Is%s WACK compliant for use in UWP apps\n", gpuInfo.isWACKCompliant ? "" : " *not*" );
         printf( "-----------------------------------------------------------------\n" );
 
-        printf( "%s, device id: 0x%04X, revision id: 0x%02X\n", gpuInfo.adapterString ? gpuInfo.adapterString : "unknown GPU", gpuInfo.deviceId, gpuInfo.revisionId );
         printf( "Radeon Software Version:   %s\n", gpuInfo.radeonSoftwareVersion );
         printf( "Driver Version:            %s\n", gpuInfo.driverVersion );
         printf( "-----------------------------------------------------------------\n" );
 
-        printf( "Is %sGCN, %d CUs, core clock %d MHz, memory clock %d MHz, %.1f Tflops\n", gpuInfo.architectureVersion == AGSGPUInfo::ArchitectureVersion_GCN ? "" : "not ", gpuInfo.iNumCUs, gpuInfo.iCoreClock, gpuInfo.iMemoryClock, gpuInfo.fTFlops );
-
-        int totalGPUs = 0;
-        if ( agsGetTotalGPUCount( agsContext, &totalGPUs ) == AGS_SUCCESS )
-        {
-            printf( "Total system GPU count = %d\n", totalGPUs );
-
-            for ( int i = 0; i < totalGPUs; i++ )
-            {
-                long long memory = 0;
-                if ( agsGetGPUMemorySize( agsContext, i, &memory ) == AGS_SUCCESS )
-                {
-                    printf( "GPU %d Memory: %dMBs\n", i, (int)(memory / (1024*1024)) );
-                }
-                else
-                {
-                    printf( "Failed to get memory size from GPU %d\n", i );
-                }
-            }
-
-            printf( "-----------------------------------------------------------------\n" );
-        }
-        else
-        {
-            printf( "Failed to get total GPU count\n" );
-        }
-
         int numCrossfireGPUs = 0;
         if ( agsGetCrossfireGPUCount( agsContext, &numCrossfireGPUs ) == AGS_SUCCESS )
         {
@@ -168,7 +173,7 @@ int main(int argc, char* argv[])
             printf( "Failed to get Crossfire GPU count\n" );
         }
 
-        GetEyefinityInfo( agsContext, primaryDisplayIndex );
+        PrintDisplayInfo( gpuInfo );
         printf( "-----------------------------------------------------------------\n" );
 
         if ( agsDeInit( agsContext ) != AGS_SUCCESS )
diff --git a/crossfire_sample/src/CFXAPISample.cpp b/crossfire_sample/src/CFXAPISample.cpp
@@ -206,7 +206,7 @@ void CFXAPISample::InitializeAMDAGS()
 {
 	// the desired Crossfire mode needs to be passed to agsInit
 	// prior to device creation
-	AGSConfiguration config;
+    AGSConfiguration config = {};
 	config.crossfireMode = AGS_CROSSFIRE_MODE_EXPLICIT_AFR;
 	agsInit (&agsContext_, &config, nullptr );
 }
@@ -277,7 +277,7 @@ void CFXAPISample::Initialize ()
 			// as the updated version is not transfered to the second GPU.
 			// With TransferApp1StepP2P, the Crossfire API will copy the
 			// data to the second GPU.
-			AGS_AFR_TRANSFER_1STEP_P2P);
+			AGS_AFR_TRANSFER_1STEP_P2P, AGS_AFR_TRANSFERENGINE_DEFAULT);
 	} else {
 		device_->CreateTexture2D (&textureDesc, nullptr, &texture_);
 	}
diff --git a/eyefinity_sample/src/EyefinitySample.cpp b/eyefinity_sample/src/EyefinitySample.cpp

Original file line number	Diff line number	Diff line change
`@@ -206,7 +206,7 @@ void CFXAPISample::InitializeAMDAGS()`
`206`	`206`	`{`
`207`	`207`	`// the desired Crossfire mode needs to be passed to agsInit`
`208`	`208`	`// prior to device creation`
`209`		`- AGSConfiguration config;`
	`209`	`+ AGSConfiguration config = {};`
`210`	`210`	`config.crossfireMode = AGS_CROSSFIRE_MODE_EXPLICIT_AFR;`
`211`	`211`	`agsInit (&agsContext_, &config, nullptr );`
`212`	`212`	`}`
`@@ -277,7 +277,7 @@ void CFXAPISample::Initialize ()`
`277`	`277`	`// as the updated version is not transfered to the second GPU.`
`278`	`278`	`// With TransferApp1StepP2P, the Crossfire API will copy the`
`279`	`279`	`// data to the second GPU.`
`280`		`- AGS_AFR_TRANSFER_1STEP_P2P);`
	`280`	`+ AGS_AFR_TRANSFER_1STEP_P2P, AGS_AFR_TRANSFERENGINE_DEFAULT);`
`281`	`281`	`} else {`
`282`	`282`	`device_->CreateTexture2D (&textureDesc, nullptr, &texture_);`
`283`	`283`	`}`