gfx/vr/service/openvr/src/hmderrors_public.cpp
author Kearwood "Kip" Gilbert <kgilbert@mozilla.com>
Wed, 24 Oct 2018 22:22:41 +0000
changeset 499309 99bb541e5ce1e45f80f914b99077752bd99d77b5
parent 472373 gfx/vr/openvr/src/hmderrors_public.cpp@e413c80dee2184685e1c9c5baa6f5096ba457359
child 508102 cfe23417875b17807be4be97c2d03ace5f2fde0d
permissions -rw-r--r--
Bug 1501455 - Remove gfx/vr/gfxVROculus.cpp and gfx/vr/gfxVROpenVR.cpp r=daoshengmu Now that the VRService thread is enabled by default, we can remove these old files. The OpenVR 3rd party code has been moved from gfx/vr/openvr to gfx/vr/service/openvr to be closer to the OpenVRSession implementation. The Oculus header (ovr_capi_dynamic.h) has been moved from gfx/vr/ovr_capi_dynamic.h to gfx/vr/service/oculus to be closer to the OculusSession implementation. Differential Revision: https://phabricator.services.mozilla.com/D9600

//========= Copyright Valve Corporation ============//
#include "openvr.h"
#include "hmderrors_public.h"
#include <stdio.h>
#include <algorithm>

using namespace vr;

#define RETURN_ENUM_AS_STRING(enumValue) case enumValue: return #enumValue;


const char *GetEnglishStringForHmdError( vr::EVRInitError eError )
{
	switch( eError )
	{
	case VRInitError_None:								return "No Error (0)";

	case VRInitError_Init_InstallationNotFound:			return "Installation Not Found (100)";
	case VRInitError_Init_InstallationCorrupt:			return "Installation Corrupt (101)";
	case VRInitError_Init_VRClientDLLNotFound:			return "vrclient Shared Lib Not Found (102)";
	case VRInitError_Init_FileNotFound:					return "File Not Found (103)";
	case VRInitError_Init_FactoryNotFound:				return "Factory Function Not Found (104)";
	case VRInitError_Init_InterfaceNotFound:			return "Interface Not Found (105)";
	case VRInitError_Init_InvalidInterface:				return "Invalid Interface (106)";
	case VRInitError_Init_UserConfigDirectoryInvalid:	return "User Config Directory Invalid (107)";
	case VRInitError_Init_HmdNotFound:					return "Hmd Not Found (108)";
	case VRInitError_Init_NotInitialized:				return "Not Initialized (109)";
	case VRInitError_Init_PathRegistryNotFound:			return "Installation path could not be located (110)";
	case VRInitError_Init_NoConfigPath:					return "Config path could not be located (111)";
	case VRInitError_Init_NoLogPath:					return "Log path could not be located (112)";
	case VRInitError_Init_PathRegistryNotWritable:		return "Unable to write path registry (113)";
	case VRInitError_Init_AppInfoInitFailed:			return "App info manager init failed (114)";
	case VRInitError_Init_Retry:						return "Internal Retry (115)";
	case VRInitError_Init_InitCanceledByUser:			return "User Canceled Init (116)";
	case VRInitError_Init_AnotherAppLaunching:			return "Another app was already launching (117)";
	case VRInitError_Init_SettingsInitFailed:			return "Settings manager init failed (118)";
	case VRInitError_Init_ShuttingDown:					return "VR system shutting down (119)";
	case VRInitError_Init_TooManyObjects:				return "Too many tracked objects (120)";
	case VRInitError_Init_NoServerForBackgroundApp:		return "Not starting vrserver for background app (121)";
	case VRInitError_Init_NotSupportedWithCompositor:	return "The requested interface is incompatible with the compositor and the compositor is running (122)";
	case VRInitError_Init_NotAvailableToUtilityApps:	return "This interface is not available to utility applications (123)";
	case VRInitError_Init_Internal:						return "vrserver internal error (124)";
	case VRInitError_Init_HmdDriverIdIsNone:			return "Hmd DriverId is invalid (125)";
	case VRInitError_Init_HmdNotFoundPresenceFailed:	return "Hmd Not Found Presence Failed (126)";
	case VRInitError_Init_VRMonitorNotFound:			return "VR Monitor Not Found (127)";
	case VRInitError_Init_VRMonitorStartupFailed:		return "VR Monitor startup failed (128)";
	case VRInitError_Init_LowPowerWatchdogNotSupported: return "Low Power Watchdog Not Supported (129)";
	case VRInitError_Init_InvalidApplicationType:		return "Invalid Application Type (130)";
	case VRInitError_Init_NotAvailableToWatchdogApps:	return "Not available to watchdog apps (131)";
	case VRInitError_Init_WatchdogDisabledInSettings:	return "Watchdog disabled in settings (132)";
	case VRInitError_Init_VRDashboardNotFound:			return "VR Dashboard Not Found (133)";
	case VRInitError_Init_VRDashboardStartupFailed:		return "VR Dashboard startup failed (134)";
	case VRInitError_Init_VRHomeNotFound:				return "VR Home Not Found (135)";
	case VRInitError_Init_VRHomeStartupFailed:			return "VR home startup failed (136)";
	case VRInitError_Init_RebootingBusy:				return "Rebooting In Progress (137)";
	case VRInitError_Init_FirmwareUpdateBusy:			return "Firmware Update In Progress (138)";
	case VRInitError_Init_FirmwareRecoveryBusy:			return "Firmware Recovery In Progress (139)";
	case VRInitError_Init_USBServiceBusy:				return "USB Service Busy (140)";

	case VRInitError_Driver_Failed:							return "Driver Failed (200)";
	case VRInitError_Driver_Unknown:						return "Driver Not Known (201)";
	case VRInitError_Driver_HmdUnknown:						return "HMD Not Known (202)";
	case VRInitError_Driver_NotLoaded:						return "Driver Not Loaded (203)";
	case VRInitError_Driver_RuntimeOutOfDate:				return "Driver runtime is out of date (204)";
	case VRInitError_Driver_HmdInUse:						return "HMD already in use by another application (205)";
	case VRInitError_Driver_NotCalibrated:					return "Device is not calibrated (206)";
	case VRInitError_Driver_CalibrationInvalid:				return "Device Calibration is invalid (207)";
	case VRInitError_Driver_HmdDisplayNotFound:				return "HMD detected over USB, but Monitor not found (208)";
	case VRInitError_Driver_TrackedDeviceInterfaceUnknown:	return "Driver Tracked Device Interface unknown (209)";
	// case VRInitError_Driver_HmdDisplayNotFoundAfterFix:	return "HMD detected over USB, but Monitor not found after attempt to fix (210)"; // taken out upon Ben's request: He thinks that there is no need to separate that error from 208
	case VRInitError_Driver_HmdDriverIdOutOfBounds:			return "Hmd DriverId is our of bounds (211)";
	case VRInitError_Driver_HmdDisplayMirrored:				return "HMD detected over USB, but Monitor may be mirrored instead of extended (212)";

	case VRInitError_IPC_ServerInitFailed:						return "VR Server Init Failed (300)";
	case VRInitError_IPC_ConnectFailed:							return "Connect to VR Server Failed (301)";
	case VRInitError_IPC_SharedStateInitFailed:					return "Shared IPC State Init Failed (302)";
	case VRInitError_IPC_CompositorInitFailed:					return "Shared IPC Compositor Init Failed (303)";
	case VRInitError_IPC_MutexInitFailed:						return "Shared IPC Mutex Init Failed (304)";
	case VRInitError_IPC_Failed:								return "Shared IPC Failed (305)";
	case VRInitError_IPC_CompositorConnectFailed:				return "Shared IPC Compositor Connect Failed (306)";
	case VRInitError_IPC_CompositorInvalidConnectResponse:		return "Shared IPC Compositor Invalid Connect Response (307)";
	case VRInitError_IPC_ConnectFailedAfterMultipleAttempts:	return "Shared IPC Connect Failed After Multiple Attempts (308)";

	case VRInitError_Compositor_Failed:					return "Compositor failed to initialize (400)";
	case VRInitError_Compositor_D3D11HardwareRequired:	return "Compositor failed to find DX11 hardware (401)";
	case VRInitError_Compositor_FirmwareRequiresUpdate:	return "Compositor requires mandatory firmware update (402)";
	case VRInitError_Compositor_OverlayInitFailed:		return "Compositor initialization succeeded, but overlay init failed (403)";
	case VRInitError_Compositor_ScreenshotsInitFailed:	return "Compositor initialization succeeded, but screenshot init failed (404)";
	case VRInitError_Compositor_UnableToCreateDevice:	return "Compositor unable to create graphics device (405)";

	// Oculus
	case VRInitError_VendorSpecific_UnableToConnectToOculusRuntime:	return "Unable to connect to Oculus Runtime (1000)";

	// Lighthouse
	case VRInitError_VendorSpecific_HmdFound_CantOpenDevice:				return "HMD found, but can not open device (1101)";
	case VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart:	return "HMD found, but unable to request config (1102)";
	case VRInitError_VendorSpecific_HmdFound_NoStoredConfig:				return "HMD found, but no stored config (1103)";
	case VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck:       return "HMD found, but failed configuration check (1113)";
	case VRInitError_VendorSpecific_HmdFound_ConfigTooBig:					return "HMD found, but config too big (1104)";
	case VRInitError_VendorSpecific_HmdFound_ConfigTooSmall:				return "HMD found, but config too small (1105)";
	case VRInitError_VendorSpecific_HmdFound_UnableToInitZLib:				return "HMD found, but unable to init ZLib (1106)";
	case VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion:		return "HMD found, but problems with the data (1107)";
	case VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart:		return "HMD found, but problems with the data (1108)";
	case VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart:		return "HMD found, but problems with the data (1109)";
	case VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext:		return "HMD found, but problems with the data (1110)";
	case VRInitError_VendorSpecific_HmdFound_UserDataAddressRange:			return "HMD found, but problems with the data (1111)";
	case VRInitError_VendorSpecific_HmdFound_UserDataError:					return "HMD found, but problems with the data (1112)";

	case VRInitError_Steam_SteamInstallationNotFound: return "Unable to find Steam installation (2000)";

	default:
		return GetIDForVRInitError( eError );
	}

}


const char *GetIDForVRInitError( vr::EVRInitError eError )
{
	switch( eError )
	{
		RETURN_ENUM_AS_STRING( VRInitError_None );
		RETURN_ENUM_AS_STRING( VRInitError_Unknown );

		RETURN_ENUM_AS_STRING( VRInitError_Init_InstallationNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_InstallationCorrupt );
		RETURN_ENUM_AS_STRING( VRInitError_Init_VRClientDLLNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_FileNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_FactoryNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_InterfaceNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_InvalidInterface );
		RETURN_ENUM_AS_STRING( VRInitError_Init_UserConfigDirectoryInvalid );
		RETURN_ENUM_AS_STRING( VRInitError_Init_HmdNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_NotInitialized );
		RETURN_ENUM_AS_STRING( VRInitError_Init_PathRegistryNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_NoConfigPath );
		RETURN_ENUM_AS_STRING( VRInitError_Init_NoLogPath );
		RETURN_ENUM_AS_STRING( VRInitError_Init_PathRegistryNotWritable );
		RETURN_ENUM_AS_STRING( VRInitError_Init_AppInfoInitFailed );
		RETURN_ENUM_AS_STRING( VRInitError_Init_Retry );
		RETURN_ENUM_AS_STRING( VRInitError_Init_InitCanceledByUser );
		RETURN_ENUM_AS_STRING( VRInitError_Init_AnotherAppLaunching );
		RETURN_ENUM_AS_STRING( VRInitError_Init_SettingsInitFailed );
		RETURN_ENUM_AS_STRING( VRInitError_Init_ShuttingDown );
		RETURN_ENUM_AS_STRING( VRInitError_Init_TooManyObjects );
		RETURN_ENUM_AS_STRING( VRInitError_Init_NoServerForBackgroundApp );
		RETURN_ENUM_AS_STRING( VRInitError_Init_NotSupportedWithCompositor );
		RETURN_ENUM_AS_STRING( VRInitError_Init_NotAvailableToUtilityApps );
		RETURN_ENUM_AS_STRING( VRInitError_Init_Internal );
		RETURN_ENUM_AS_STRING( VRInitError_Init_HmdDriverIdIsNone );
		RETURN_ENUM_AS_STRING( VRInitError_Init_HmdNotFoundPresenceFailed );
		RETURN_ENUM_AS_STRING( VRInitError_Init_VRMonitorNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_VRMonitorStartupFailed );
		RETURN_ENUM_AS_STRING( VRInitError_Init_LowPowerWatchdogNotSupported );
		RETURN_ENUM_AS_STRING( VRInitError_Init_InvalidApplicationType );
		RETURN_ENUM_AS_STRING( VRInitError_Init_NotAvailableToWatchdogApps );
		RETURN_ENUM_AS_STRING( VRInitError_Init_WatchdogDisabledInSettings );
		RETURN_ENUM_AS_STRING( VRInitError_Init_VRDashboardNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_VRDashboardStartupFailed );
		RETURN_ENUM_AS_STRING( VRInitError_Init_VRHomeNotFound );
		RETURN_ENUM_AS_STRING( VRInitError_Init_VRHomeStartupFailed );
		RETURN_ENUM_AS_STRING( VRInitError_Init_RebootingBusy );
		RETURN_ENUM_AS_STRING( VRInitError_Init_FirmwareUpdateBusy );
		RETURN_ENUM_AS_STRING( VRInitError_Init_FirmwareRecoveryBusy );
		RETURN_ENUM_AS_STRING( VRInitError_Init_USBServiceBusy );
		RETURN_ENUM_AS_STRING( VRInitError_Init_VRWebHelperStartupFailed );

		RETURN_ENUM_AS_STRING( VRInitError_Driver_Failed );
		RETURN_ENUM_AS_STRING( VRInitError_Driver_Unknown );
		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdUnknown);
		RETURN_ENUM_AS_STRING( VRInitError_Driver_NotLoaded);
		RETURN_ENUM_AS_STRING( VRInitError_Driver_RuntimeOutOfDate);
		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdInUse);
		RETURN_ENUM_AS_STRING( VRInitError_Driver_NotCalibrated);
		RETURN_ENUM_AS_STRING( VRInitError_Driver_CalibrationInvalid);
		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDisplayNotFound);
		RETURN_ENUM_AS_STRING( VRInitError_Driver_TrackedDeviceInterfaceUnknown );
		// RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDisplayNotFoundAfterFix );
		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDriverIdOutOfBounds );
		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDisplayMirrored );

		RETURN_ENUM_AS_STRING( VRInitError_IPC_ServerInitFailed);
		RETURN_ENUM_AS_STRING( VRInitError_IPC_ConnectFailed);
		RETURN_ENUM_AS_STRING( VRInitError_IPC_SharedStateInitFailed);
		RETURN_ENUM_AS_STRING( VRInitError_IPC_CompositorInitFailed);
		RETURN_ENUM_AS_STRING( VRInitError_IPC_MutexInitFailed);
		RETURN_ENUM_AS_STRING( VRInitError_IPC_Failed);
		RETURN_ENUM_AS_STRING( VRInitError_IPC_CompositorConnectFailed);
		RETURN_ENUM_AS_STRING( VRInitError_IPC_CompositorInvalidConnectResponse);
		RETURN_ENUM_AS_STRING( VRInitError_IPC_ConnectFailedAfterMultipleAttempts);

		RETURN_ENUM_AS_STRING( VRInitError_Compositor_Failed );
		RETURN_ENUM_AS_STRING( VRInitError_Compositor_D3D11HardwareRequired );
		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FirmwareRequiresUpdate );
		RETURN_ENUM_AS_STRING( VRInitError_Compositor_OverlayInitFailed );
		RETURN_ENUM_AS_STRING( VRInitError_Compositor_ScreenshotsInitFailed );
		RETURN_ENUM_AS_STRING( VRInitError_Compositor_UnableToCreateDevice );

		// Vendor-specific errors
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_UnableToConnectToOculusRuntime);
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_WindowsNotInDevMode );

		// Lighthouse
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_CantOpenDevice);
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart);
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_NoStoredConfig);
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_ConfigTooBig );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_ConfigTooSmall );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToInitZLib );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UserDataAddressRange );
		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UserDataError );

		RETURN_ENUM_AS_STRING( VRInitError_Steam_SteamInstallationNotFound );

	default:
		{
			static char buf[128];
			sprintf( buf, "Unknown error (%d)", eError );
			return buf;
		}
	}
}