SetMasterVolumeLevel without pycaw dependency.

[BoQsc]

I've been having a hard time looking on the internet for simple portable way to SetMasterVolumeLevel natively.
I'm not aware of how pycaw works, but I really need to be simplistic and can not afford to install the entire pycaw.
I merely want to depend only on Python Standard Library.

What are the chances to achieve SetMasterVolumeLevel behaviour in a single python function, or is it terminally hard?

[gexgd0419]

To set the master volume level on Windows Vista and above, you will have to use WASAPI, which is a COM API.

There are libraries such as comtypes and win32com that can simplify using COM in Python, but neither of them is a standard library.

In fact, pycaw is based on comtypes. pycaw provides some frequently-used utility functions, but the returned COM object wrappers that you call SetMasterVolumeLevel on are still provided by comtypes.

Pure C APIs are a little bit easier to call in Python with ctypes (a standard library). While Windows does have some C APIs such as waveOutSetVolume, they can no longer adjust the master volume like they did in Windows XP. Now they can only affect the volume of the current application. To adjust the master volume, you have to use the COM-based WASAPI.

If you really want to use WASAPI without third-party libraries, it is still possible to use COM with ctypes only. You can manually call the C API CoCreateInstance to create COM objects, and call the COM methods using their vtable indices.

import ctypes
from ctypes import HRESULT, POINTER, WINFUNCTYPE, byref, c_void_p, c_float
from ctypes.wintypes import BOOL, DWORD
from uuid import UUID

# Constants
CLSID_MMDeviceEnumerator = UUID("{bcde0395-e52f-467c-8e3d-c4579291692e}")
IID_IMMDeviceEnumerator = UUID("{a95664d2-9614-4f35-a746-de8db63617e6}")
IID_IAudioEndpointVolume = UUID("{5CDF2C82-841E-4546-9722-0CF74078229A}")
CLSCTX_ALL = 23
eRender = 0
eConsole = 0

ole32 = ctypes.oledll.ole32

# Function types for COM methods

# HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID *ppv)
ole32.CoCreateInstance.argtypes = c_void_p, c_void_p, DWORD, c_void_p, POINTER(c_void_p)

# ULONG IUnknown::Release(void)
com_Release = WINFUNCTYPE(DWORD)(2, "Release")

# HRESULT IMMDeviceEnumerator::GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role, IMMDevice **ppEndpoint)
IMMDeviceEnumerator_GetDefaultAudioEndpoint = WINFUNCTYPE(
    HRESULT, DWORD, DWORD, POINTER(c_void_p))(4, "GetDefaultAudioEndpoint")

# HRESULT IMMDevice::Activate(REFIID iid, DWORD dwClsCtx, PROPVARIANT *pActivationParams, void **ppInterface)
IMMDevice_Activate = WINFUNCTYPE(
    HRESULT, c_void_p, DWORD, c_void_p, POINTER(c_void_p))(3, "Activate")

# HRESULT IAudioEndpointVolume::SetMasterVolumeLevel(float fLevelDB, LPCGUID pguidEventContext)
IAudioEndpointVolume_SetMasterVolumeLevel = WINFUNCTYPE(
    HRESULT, c_float, c_void_p)(6, "SetMasterVolumeLevel")

# HRESULT IAudioEndpointVolume::SetMasterVolumeLevelScalar(float fLevel, LPCGUID pguidEventContext)
IAudioEndpointVolume_SetMasterVolumeLevelScalar = WINFUNCTYPE(
    HRESULT, c_float, c_void_p)(7, "SetMasterVolumeLevelScalar")

# HRESULT IAudioEndpointVolume::GetMasterVolumeLevel(float *pfLevelDB)
IAudioEndpointVolume_GetMasterVolumeLevel = WINFUNCTYPE(
    HRESULT, POINTER(c_float))(8, "GetMasterVolumeLevel", ((2,),))

# HRESULT IAudioEndpointVolume::GetMasterVolumeLevelScalar(float *pfLevel)
IAudioEndpointVolume_GetMasterVolumeLevelScalar = WINFUNCTYPE(
    HRESULT, POINTER(c_float))(9, "GetMasterVolumeLevelScalar", ((2,),))

# HRESULT IAudioEndpointVolume::SetMute(BOOL bMute, LPCGUID pguidEventContext)
IAudioEndpointVolume_SetMute = WINFUNCTYPE(
    HRESULT, BOOL, c_void_p)(14, "SetMute")

# HRESULT IAudioEndpointVolume::GetMute(BOOL* pbMute)
IAudioEndpointVolume_GetMute = WINFUNCTYPE(
    HRESULT, POINTER(BOOL))(15, "GetMute", ((2,),))

# Initialize COM
ole32.CoInitialize(None)

# Create a MMDeviceEnumerator object
pEnumerator = c_void_p()
ole32.CoCreateInstance(
    CLSID_MMDeviceEnumerator.bytes_le,
    None,
    CLSCTX_ALL,
    IID_IMMDeviceEnumerator.bytes_le,
    byref(pEnumerator)
)

# Get the default output device (endpoint)
pEndpoint = c_void_p()
IMMDeviceEnumerator_GetDefaultAudioEndpoint(pEnumerator, eRender, eConsole, byref(pEndpoint))
com_Release(pEnumerator)

# Get the volume control of the device (endpoint)
pVolume = c_void_p()
IMMDevice_Activate(pEndpoint, IID_IAudioEndpointVolume.bytes_le, CLSCTX_ALL, None, byref(pVolume))
com_Release(pEndpoint)

# Get/Set the volume in decibel
volume_db = IAudioEndpointVolume_GetMasterVolumeLevel(pVolume)
IAudioEndpointVolume_SetMasterVolumeLevel(pVolume, -20, None) # -20db

# Get/Set the volume in level from 0.0 to 1.0
volume = IAudioEndpointVolume_GetMasterVolumeLevelScalar(pVolume)
IAudioEndpointVolume_SetMasterVolumeLevelScalar(pVolume, 0.4, None) # 40%

# Get/Set the mute status
isMute = bool(IAudioEndpointVolume_GetMute(pVolume))
IAudioEndpointVolume_SetMute(pVolume, True, None)

# Cleanup
com_Release(pVolume)
ole32.CoUninitialize()

As you can see here, the prototype of every COM method you use has to be defined. Also, as the functions are "global", you have to call those methods with the first argument being the object itself, such as:

volume_db = IAudioEndpointVolume_GetMasterVolumeLevel(pVolume)

instead of the more intuitive:

volume_db = pVolume.GetMasterVolumeLevel()

You have to "release" the COM objects manually as well.

What libraries such as comtypes do is to provide a nice wrapper around those native COM support, so that you can use COM objects more like Python objects. For example, you can call COM methods using the dot syntax, and the COM object will be automatically released when the Python wrapper is deleted.

comtypes still requires you to provide the details of the COM interfaces you use (such as IMMDeviceEnumerator and IAudioEndpointVolume). But pycaw contains the details, so you don't have to write the prototypes yourself.