pyglet 2.0.8__zip → 2.0.10__zip

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/devices/base.py

@@ -1,41 +1,42 @@
 from abc import ABCMeta, abstractmethod
+from enum import Enum, auto
+from typing import Dict, Optional
 
 from pyglet import event
-from pyglet.util import with_metaclass
 
 
-class DeviceState:
-    ACTIVE = "active"
-    DISABLED = "disabled"
-    MISSING = "missing"
-    UNPLUGGED = "unplugged"
+class DeviceState(Enum):
+    ACTIVE = auto()
+    DISABLED = auto()
+    MISSING = auto()
+    UNPLUGGED = auto()
 
 
-class DeviceFlow:
-    OUTPUT = "output"
-    INPUT = "input"
-    INPUT_OUTPUT = "input/output"
+class DeviceFlow(Enum):
+    OUTPUT = auto()
+    INPUT = auto()
+    INPUT_OUTPUT = auto()
 
 
 class AudioDevice:
     """Base class for a platform independent audio device.
        _platform_state and _platform_flow is used to make device state numbers."""
-    _platform_state = {}  # Must be defined by the parent.
-    _platform_flow = {}  # Must be defined by the parent.
+    platform_state: Dict[int, DeviceState] = {}  # Must be defined by the parent.
+    platform_flow: Dict[int, DeviceFlow] = {}  # Must be defined by the parent.
 
-    def __init__(self, dev_id, name, description, flow, state):
+    def __init__(self, dev_id: str, name: str, description: str, flow: int, state: int):
         self.id = dev_id
-        self.flow = flow
-        self.state = state
+        self.flow = flow  # platform value
+        self.state = state  # platform value
         self.name = name
         self.description = description
 
     def __repr__(self):
-        return "{}(name={}, state={}, flow={})".format(
-            self.__class__.__name__, self.name, self._platform_state[self.state], self._platform_flow[self.flow])
+        return "{}(name='{}', state={}, flow={})".format(
+            self.__class__.__name__, self.name, self.platform_state[self.state].name, self.platform_flow[self.flow].name)
 
 
-class AbstractAudioDeviceManager(with_metaclass(ABCMeta, event.EventDispatcher, object)):
+class AbstractAudioDeviceManager(event.EventDispatcher, metaclass=ABCMeta):
 
     def __del__(self):
         """Required to remove handlers before exit, as it can cause problems with the event system's weakrefs."""
@@ -66,20 +67,23 @@ class AbstractAudioDeviceManager(with_metaclass(ABCMeta, event.EventDispatcher,
         """Returns a list of all audio devices, no matter what state they are in."""
         pass
 
-    def on_device_state_changed(self, device, old_state, new_state):
-        """Event, occurs when the state of a device changes, provides old state and new state."""
+    def on_device_state_changed(self, device: AudioDevice, old_state: DeviceState, new_state: DeviceState):
+        """Event, occurs when the state of a device changes, provides the old state and new state."""
         pass
 
-    def on_device_added(self, device):
+    def on_device_added(self, device: AudioDevice):
         """Event, occurs when a new device is added to the system."""
         pass
 
-    def on_device_removed(self, device):
+    def on_device_removed(self, device: AudioDevice):
         """Event, occurs when an existing device is removed from the system."""
         pass
 
-    def on_default_changed(self, device):
-        """Event, occurs when the default audio device changes."""
+    def on_default_changed(self, device: Optional[AudioDevice], flow: DeviceFlow):
+        """Event, occurs when the default audio device changes.
+           If there is no device that can be the default on the system, can be None.
+           The flow determines whether an input or output device became it's respective default.
+        """
         pass
 
 

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/devices/win32.py

@@ -1,3 +1,5 @@
+from typing import List, Optional, Tuple
+
 from pyglet.libs.win32 import com
 from pyglet.libs.win32 import _ole32 as ole32
 from pyglet.libs.win32.constants import CLSCTX_INPROC_SERVER
@@ -5,7 +7,7 @@ from pyglet.libs.win32.types import *
 from pyglet.media.devices import base
 from pyglet.util import debug_print
 
-_debug = debug_print('debug_media')
+_debug = debug_print('debug_input')
 
 EDataFlow = UINT
 # Audio rendering stream. Audio data flows from the application to the audio endpoint device, which renders the stream.
@@ -49,7 +51,7 @@ class PROPERTYKEY(ctypes.Structure):
         return "PROPERTYKEY({}, pid={})".format(self.fmtid, self.pid)
 
 
-REFPROPERTYKEY = PROPERTYKEY
+REFPROPERTYKEY = POINTER(PROPERTYKEY)
 
 PKEY_Device_FriendlyName = PROPERTYKEY(
     com.GUID(0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0), 14)
@@ -81,45 +83,60 @@ IID_IMMDeviceEnumerator = com.GUID(0xa95664d2, 0x9614, 0x4f35, 0xa7, 0x46, 0xde,
 class IMMNotificationClient(com.IUnknown):
     _methods_ = [
         ('OnDeviceStateChanged',
-         com.METHOD(ctypes.c_void_p, ctypes.c_void_p, LPCWSTR, DWORD)),
+         com.STDMETHOD(LPCWSTR, DWORD)),
         ('OnDeviceAdded',
-         com.METHOD(ctypes.c_void_p, ctypes.c_void_p, LPCWSTR)),
+         com.STDMETHOD(LPCWSTR)),
         ('OnDeviceRemoved',
-         com.METHOD(ctypes.c_void_p, ctypes.c_void_p, LPCWSTR)),
+         com.STDMETHOD(LPCWSTR)),
         ('OnDefaultDeviceChanged',
-         com.METHOD(ctypes.c_void_p, ctypes.c_void_p, EDataFlow, ERole, LPCWSTR)),
+         com.STDMETHOD(EDataFlow, ERole, LPCWSTR)),
         ('OnPropertyValueChanged',
-         com.METHOD(ctypes.c_void_p, ctypes.c_void_p, LPCWSTR, PROPERTYKEY)),
+         com.STDMETHOD(LPCWSTR, PROPERTYKEY)),
+    ]
+
+
+IID_IMMEndpoint = com.GUID(0x1BE09788, 0x6894, 0x4089, 0x85, 0x86, 0x9A, 0x2A, 0x6C, 0x26, 0x5A, 0xC5)
+
+
+class IMMEndpoint(com.pIUnknown):
+    _methods_ = [
+        ('GetDataFlow',
+         com.STDMETHOD(POINTER(EDataFlow))),
     ]
 
 
 class AudioNotificationCB(com.COMObject):
     _interfaces_ = [IMMNotificationClient]
 
-    def __init__(self, audio_devices):
+    def __init__(self, audio_devices: 'Win32AudioDeviceManager'):
         super().__init__()
         self.audio_devices = audio_devices
         self._lost = False
 
-    def OnDeviceStateChanged(self, this, pwstrDeviceId, dwNewState):
+    def OnDeviceStateChanged(self, pwstrDeviceId, dwNewState):
         device = self.audio_devices.get_cached_device(pwstrDeviceId)
 
         old_state = device.state
+
+        pyglet_old_state = Win32AudioDevice.platform_state[old_state]
+        pyglet_new_state = Win32AudioDevice.platform_state[dwNewState]
         assert _debug(
-            "Audio device {} changed state. From state: {} to state: {}".format(device.name, old_state, dwNewState))
+            f"Audio device '{device.name}' changed state. From: {pyglet_old_state} to: {pyglet_new_state}")
 
         device.state = dwNewState
-        self.audio_devices.dispatch_event('on_device_state_changed', device, old_state, dwNewState)
+        self.audio_devices.dispatch_event('on_device_state_changed', device, pyglet_old_state, pyglet_new_state)
 
-    def OnDeviceAdded(self, this, pwstrDeviceId):
-        assert _debug("Audio device was added {}".format(pwstrDeviceId))
-        self.audio_devices.dispatch_event('on_device_added', pwstrDeviceId)
+    def OnDeviceAdded(self, pwstrDeviceId):
+        dev = self.audio_devices.add_device(pwstrDeviceId)
+        assert _debug(f"Audio device was added {pwstrDeviceId}: {dev}")
+        self.audio_devices.dispatch_event('on_device_added', dev)
 
-    def OnDeviceRemoved(self, this, pwstrDeviceId):
-        assert _debug("Audio device was removed {}".format(pwstrDeviceId))
-        self.audio_devices.dispatch_event('on_device_removed', pwstrDeviceId)
+    def OnDeviceRemoved(self, pwstrDeviceId):
+        dev = self.audio_devices.remove_device(pwstrDeviceId)
+        assert _debug(f"Audio device was removed {pwstrDeviceId} : {dev}")
+        self.audio_devices.dispatch_event('on_device_removed', dev)
 
-    def OnDefaultDeviceChanged(self, this, flow, role, pwstrDeviceId):
+    def OnDefaultDeviceChanged(self, flow, role, pwstrDeviceId):
         # Only support eConsole role right now
         if role == 0:
             if pwstrDeviceId is None:
@@ -127,9 +144,12 @@ class AudioNotificationCB(com.COMObject):
             else:
                 device = self.audio_devices.get_cached_device(pwstrDeviceId)
 
-            self.audio_devices.dispatch_event('on_default_changed', device)
+            pyglet_flow = Win32AudioDevice.platform_flow[flow]
+            assert _debug(f"Default device was changed to: {device} ({pyglet_flow})")
+
+            self.audio_devices.dispatch_event('on_default_changed', device, pyglet_flow)
 
-    def OnPropertyValueChanged(self, this, pwstrDeviceId, key):
+    def OnPropertyValueChanged(self, pwstrDeviceId, key):
         pass
 
 
@@ -171,14 +191,14 @@ class IMMDeviceEnumerator(com.pIUnknown):
 
 
 class Win32AudioDevice(base.AudioDevice):
-    _platform_state = {
+    platform_state = {
         DEVICE_STATE_ACTIVE: base.DeviceState.ACTIVE,
         DEVICE_STATE_DISABLED: base.DeviceState.DISABLED,
         DEVICE_STATE_NOTPRESENT: base.DeviceState.MISSING,
         DEVICE_STATE_UNPLUGGED: base.DeviceState.UNPLUGGED
     }
 
-    _platform_flow = {
+    platform_flow = {
         eRender: base.DeviceFlow.OUTPUT,
         eCapture: base.DeviceFlow.INPUT,
         eAll: base.DeviceFlow.INPUT_OUTPUT
@@ -192,14 +212,42 @@ class Win32AudioDeviceManager(base.AbstractAudioDeviceManager):
                                byref(self._device_enum))
 
         # Keep all devices cached, and the callback can keep them updated.
-        self.devices = self._query_all_devices()
+        self.devices: List[Win32AudioDevice] = self._query_all_devices()
 
         super().__init__()
 
         self._callback = AudioNotificationCB(self)
         self._device_enum.RegisterEndpointNotificationCallback(self._callback)
 
-    def get_default_output(self):
+    def add_device(self, pwstrDeviceId: str) -> Win32AudioDevice:
+        dev = self.get_device(pwstrDeviceId)
+        self.devices.append(dev)
+        return dev
+
+    def remove_device(self, pwstrDeviceId: str) -> Win32AudioDevice:
+        dev = self.audio_devices.get_cached_device(pwstrDeviceId)
+        self.audio_devices.devices.remove(dev)
+        return dev
+
+    def get_device(self, pwstrDeviceId: str) -> Win32AudioDevice:
+        device = IMMDevice()
+
+        self._device_enum.GetDevice(pwstrDeviceId, byref(device))
+        dev_id, name, desc, dev_state = self.get_device_info(device)
+
+        ep = IMMEndpoint()
+        device.QueryInterface(IID_IMMEndpoint, byref(ep))
+
+        dataflow = EDataFlow()
+        ep.GetDataFlow(byref(dataflow))
+        flow = dataflow.value
+
+        windevice = Win32AudioDevice(dev_id, name, desc, flow, dev_state)
+        ep.Release()
+        device.Release()
+        return windevice
+
+    def get_default_output(self) -> Optional[Win32AudioDevice]:
         """Attempts to retrieve a default audio output for the system. Returns None if no available devices found."""
         try:
             device = IMMDevice()
@@ -207,14 +255,14 @@ class Win32AudioDeviceManager(base.AbstractAudioDeviceManager):
             dev_id, name, desc, dev_state = self.get_device_info(device)
             device.Release()
 
-            pid = self.get_cached_device(dev_id)
-            pid.state = dev_state
-            return pid
-        except OSError:
-            assert _debug("No default audio output was found.")
+            cached_dev = self.get_cached_device(dev_id)
+            cached_dev.state = dev_state
+            return cached_dev
+        except OSError as err:
+            assert _debug("No default audio output was found.", err)
             return None
 
-    def get_default_input(self):
+    def get_default_input(self) -> Optional[Win32AudioDevice]:
         """Attempts to retrieve a default audio input for the system. Returns None if no available devices found."""
         try:
             device = IMMDevice()
@@ -222,37 +270,35 @@ class Win32AudioDeviceManager(base.AbstractAudioDeviceManager):
             dev_id, name, desc, dev_state = self.get_device_info(device)
             device.Release()
 
-            pid = self.get_cached_device(dev_id)
-            pid.state = dev_state
-            return pid
-        except OSError:
-            assert _debug("No default input output was found.")
+            cached_dev = self.get_cached_device(dev_id)
+            cached_dev.state = dev_state
+            return cached_dev
+        except OSError as err:
+            assert _debug("No default input output was found.", err)
             return None
 
-    def get_cached_device(self, dev_id):
+    def get_cached_device(self, dev_id) -> Win32AudioDevice:
         """Gets the cached devices, so we can reduce calls to COM and tell current state vs new states."""
         for device in self.devices:
             if device.id == dev_id:
                 return device
 
-        raise Exception("Attempted to get a device that does not exist.")
-
-        # return None
+        raise Exception("Attempted to get a device that does not exist.", dev_id)
 
-    def get_output_devices(self, state=DEVICE_STATE_ACTIVE):
+    def get_output_devices(self, state=DEVICE_STATE_ACTIVE) -> List[Win32AudioDevice]:
         return [device for device in self.devices if device.state == state and device.flow == eRender]
 
-    def get_input_devices(self, state=DEVICE_STATE_ACTIVE):
+    def get_input_devices(self, state=DEVICE_STATE_ACTIVE) -> List[Win32AudioDevice]:
         return [device for device in self.devices if device.state == state and device.flow == eCapture]
 
-    def get_all_devices(self):
+    def get_all_devices(self) -> List[Win32AudioDevice]:
         return self.devices
 
-    def _query_all_devices(self):
+    def _query_all_devices(self) -> List[Win32AudioDevice]:
         return self.get_devices(flow=eRender, state=DEVICE_STATEMASK_ALL) + self.get_devices(flow=eCapture,
                                                                                              state=DEVICE_STATEMASK_ALL)
 
-    def get_device_info(self, device):
+    def get_device_info(self, device: IMMDevice) -> Tuple[str, str, str, int]:
         """Return the ID, Name, and Description of the Audio Device."""
         store = IPropertyStore()
         device.OpenPropertyStore(STGM_READ, byref(store))
@@ -293,13 +339,13 @@ class Win32AudioDeviceManager(base.AbstractAudioDeviceManager):
         return devices
 
     @staticmethod
-    def get_pkey_value(store, pkey):
+    def get_pkey_value(store: IPropertyStore, pkey: PROPERTYKEY):
         try:
             propvar = PROPVARIANT()
             store.GetValue(pkey, byref(propvar))
             value = propvar.pwszVal
-            ole32.PropVariantClear(propvar)
-        except Exception as err:
+            ole32.PropVariantClear(byref(propvar))
+        except Exception:
             value = "Unknown"
 
         return value

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/drivers/base.py

@@ -4,10 +4,9 @@ import weakref
 from abc import ABCMeta, abstractmethod
 
 import pyglet
-from pyglet.util import with_metaclass
 
 
-class AbstractAudioPlayer(with_metaclass(ABCMeta)):
+class AbstractAudioPlayer(metaclass=ABCMeta):
     """Base class for driver audio players.
     """
 
@@ -165,7 +164,10 @@ class AbstractAudioPlayer(with_metaclass(ABCMeta)):
 
     @property
     def source(self):
-        """Source to play from."""
+        """Source to play from.
+        May be swapped out for one of an equal audio format, but ensure that
+        the player has been paused and cleared beforehand.
+        """
         return self._source
 
     @source.setter
@@ -173,7 +175,7 @@ class AbstractAudioPlayer(with_metaclass(ABCMeta)):
         self._source = weakref.proxy(value)
 
 
-class AbstractAudioDriver(with_metaclass(ABCMeta)):
+class AbstractAudioDriver(metaclass=ABCMeta):
     @abstractmethod
     def create_audio_player(self, source, player):
         pass

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/drivers/directsound/adaptation.py

@@ -69,6 +69,10 @@ class DirectSoundAudioPlayer(AbstractAudioPlayer):
         # eos for one buffer size.
         self._eos_cursor = None
 
+        # Whether the source has hit its end; protect against duplicate
+        # dispatch of on_eos events.
+        self._has_underrun = False
+
         # Indexes into DSound circular buffer.  Complications ensue wrt each
         # other to avoid writing over the play cursor.  See _get_write_size and
         # write().
@@ -101,13 +105,13 @@ class DirectSoundAudioPlayer(AbstractAudioPlayer):
 
     def play(self):
         assert _debug('DirectSound play')
-        self.driver.worker.add(self)
 
         if not self._playing:
-            self._get_audiodata()  # prebuffer if needed
             self._playing = True
+            self._get_audiodata()  # prebuffer if needed
             self._ds_buffer.play()
 
+        self.driver.worker.add(self)
         assert _debug('return DirectSound play')
 
     def stop(self):
@@ -128,6 +132,7 @@ class DirectSoundAudioPlayer(AbstractAudioPlayer):
         self._play_cursor = self._write_cursor
         self._eos_cursor = None
         self._audiodata_buffer = None
+        self._has_underrun = False
         del self._events[:]
         del self._timestamps[:]
 
@@ -153,10 +158,6 @@ class DirectSoundAudioPlayer(AbstractAudioPlayer):
                 self.write(None, write_size)
                 write_size = 0
 
-    def _has_underrun(self):
-        return (self._eos_cursor is not None
-                and self._play_cursor > self._eos_cursor)
-
     def _dispatch_new_event(self, event_name):
         MediaEvent(event_name).sync_dispatch_to_player(self.player)
 
@@ -243,9 +244,13 @@ class DirectSoundAudioPlayer(AbstractAudioPlayer):
             del self._timestamps[0]
 
     def _check_underrun(self):
-        if self._playing and self._has_underrun():
+        if (
+            not self._has_underrun and
+            self._playing and
+            (self._eos_cursor is not None and self._play_cursor > self._eos_cursor)
+        ):
             assert _debug('underrun, stopping')
-            self.stop()
+            self._has_underrun = True
             self._dispatch_new_event('on_eos')
 
     def _get_write_size(self):

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/drivers/directsound/lib_dsound.py

@@ -270,7 +270,6 @@ class IDirectSound(com.pIUnknown):
         ('Initialize', 
          com.STDMETHOD(com.LPGUID)),
     ]
-    _type_ = com.COMInterface
 
 DirectSoundCreate = lib.DirectSoundCreate
 DirectSoundCreate.argtypes = \

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/drivers/listener.py

@@ -1,9 +1,7 @@
 from abc import ABCMeta, abstractmethod
 
-from pyglet.util import with_metaclass
 
-
-class AbstractListener(with_metaclass(ABCMeta, object)):
+class AbstractListener(metaclass=ABCMeta):
     """The listener properties for positional audio.
 
     You can obtain the singleton instance of this class by calling

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/drivers/openal/adaptation.py

@@ -101,6 +101,10 @@ class OpenALAudioPlayer(AbstractAudioPlayer):
         # Cursor position of end of queued AL buffer.
         self._write_cursor = 0
 
+        # Whether the source hit its end; protect against duplicate dispatch
+        # of on_eos events.
+        self._has_underrun = False
+
         # List of currently queued buffer sizes (in bytes)
         self._buffer_sizes = []
 
@@ -177,6 +181,7 @@ class OpenALAudioPlayer(AbstractAudioPlayer):
         self._buffer_cursor = 0
         self._play_cursor = 0
         self._write_cursor = 0
+        self._has_underrun = False
         del self._events[:]
         del self._buffer_sizes[:]
         del self._buffer_timestamps[:]
@@ -271,15 +276,15 @@ class OpenALAudioPlayer(AbstractAudioPlayer):
     def _get_new_audiodata(self):
         assert _debug('Getting new audio data buffer.')
         compensation_time = self.get_audio_time_diff()
-        self._audiodata_buffer= self.source.get_audio_data(self.ideal_buffer_size, compensation_time)
+        self._audiodata_buffer = self.source.get_audio_data(self.ideal_buffer_size, compensation_time)
 
         if self._audiodata_buffer is not None:
             assert _debug('New audio data available: {} bytes'.format(self._audiodata_buffer.length))
             self._queue_events(self._audiodata_buffer)
         else:
             assert _debug('No audio data left')
-            if self._has_underrun():
-                assert _debug('Underrun')
+            if self._has_just_underrun():
+                assert _debug('Freshly underrun')
                 MediaEvent('on_eos').sync_dispatch_to_player(self.player)
 
     def _queue_audio_data(self, audio_data, length):
@@ -297,12 +302,17 @@ class OpenALAudioPlayer(AbstractAudioPlayer):
 
     def _queue_events(self, audio_data):
         for event in audio_data.events:
-            cursor = self._write_cursor + event.timestamp * \
-                self.source.audio_format.bytes_per_second
+            cursor = self._write_cursor + event.timestamp * self.source.audio_format.bytes_per_second
             self._events.append((cursor, event))
 
-    def _has_underrun(self):
-        return self.alsource.buffers_queued == 0
+    def _has_just_underrun(self):
+        if self._has_underrun:
+            return False
+
+        if self.alsource.buffers_queued == 0:
+            self._has_underrun = True
+
+        return self._has_underrun
 
     def get_time(self):
         # Update first, might remove buffers

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/drivers/xaudio2/adaptation.py

@@ -89,7 +89,6 @@ class XAudio2AudioPlayer(AbstractAudioPlayer):
             if not self._buffers:
                 self._xa2_driver.return_voice(self._xa2_source_voice)
 
-
     def play(self):
         assert _debug('XAudio2 play')
 
@@ -137,6 +136,8 @@ class XAudio2AudioPlayer(AbstractAudioPlayer):
         Unlike the other drivers this does not carve pieces of audio from the buffer and slowly
         consume it. This submits the buffer retrieved from the decoder in it's entirety.
         """
+        if not self._xa2_source_voice:
+            return
 
         buffers_queued = self._xa2_source_voice.buffers_queued
 

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/drivers/xaudio2/interface.py

@@ -1,6 +1,8 @@
 import weakref
 from collections import namedtuple, defaultdict
 
+from pyglet.media.devices.base import DeviceFlow
+
 import pyglet
 from pyglet.libs.win32.types import *
 from pyglet.util import debug_print
@@ -69,15 +71,16 @@ class XAudio2Driver:
 
                 self._players.clear()
 
-    def on_default_changed(self, device):
-        """Callback derived from the Audio Devices to help us determine when the system no longer has output."""
-        if device is None:
-            assert _debug('Error: Default audio device was removed or went missing.')
-            self._dead = True
-        else:
-            if self._dead:
-                assert _debug('Warning: Default audio device added after going missing.')
-                self._dead = False
+    def on_default_changed(self, device, flow: DeviceFlow):
+        if flow == DeviceFlow.OUTPUT:
+            """Callback derived from the Audio Devices to help us determine when the system no longer has output."""
+            if device is None:
+                assert _debug('Error: Default audio device was removed or went missing.')
+                self._dead = True
+            else:
+                if self._dead:
+                    assert _debug('Warning: Default audio device added after going missing.')
+                    self._dead = False
 
     def _create_xa2(self, device_id=None):
         self._xaudio2 = lib.IXAudio2()

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/media/drivers/xaudio2/lib_xaudio2.py

@@ -192,17 +192,19 @@ XAUDIO2_NO_VIRTUAL_AUDIO_CLIENT = 0x10000   # Used in CreateMasteringVoice to cr
 class IXAudio2VoiceCallback(com.Interface):
     _methods_ = [
         ('OnVoiceProcessingPassStart',
-         com.STDMETHOD(UINT32)),
+         com.VOIDMETHOD(UINT32)),
         ('OnVoiceProcessingPassEnd',
-         com.STDMETHOD()),
-        ('onStreamEnd',
-         com.STDMETHOD()),
-        ('onBufferStart',
-         com.STDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD()),
+        ('OnStreamEnd',
+         com.VOIDMETHOD()),
+        ('OnBufferStart',
+         com.VOIDMETHOD(ctypes.c_void_p)),
         ('OnBufferEnd',
-         com.STDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD(ctypes.c_void_p)),
         ('OnLoopEnd',
-         com.STDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD(ctypes.c_void_p)),
+        ('OnVoiceError',
+         com.VOIDMETHOD(ctypes.c_void_p, HRESULT))
     ]
 
 
@@ -220,20 +222,9 @@ class XA2SourceCallback(com.COMObject):
     _interfaces_ = [IXAudio2VoiceCallback]
 
     def __init__(self, xa2_player):
+        super().__init__()
         self.xa2_player = xa2_player
 
-    def OnVoiceProcessingPassStart(self, bytesRequired):
-        pass
-
-    def OnVoiceProcessingPassEnd(self):
-        pass
-
-    def onStreamEnd(self):
-        pass
-
-    def onBufferStart(self, pBufferContext):
-        pass
-
     def OnBufferEnd(self, pBufferContext):
         """At the end of playing one buffer, attempt to refill again.
         Even if the player is out of sources, it needs to be called to purge all buffers.
@@ -241,10 +232,7 @@ class XA2SourceCallback(com.COMObject):
         if self.xa2_player:
             self.xa2_player.refill_source_player()
 
-    def OnLoopEnd(self, this, pBufferContext):
-        pass
-
-    def onVoiceError(self, this, pBufferContext, hresult):
+    def OnVoiceError(self, pBufferContext, hresult):
         raise Exception("Error occurred during audio playback.", hresult)
 
 
@@ -362,24 +350,18 @@ class IXAudio2MasteringVoice(IXAudio2Voice):
 class IXAudio2EngineCallback(com.Interface):
     _methods_ = [
         ('OnProcessingPassStart',
-         com.METHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD()),
         ('OnProcessingPassEnd',
-         com.METHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD()),
         ('OnCriticalError',
-         com.METHOD(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_ulong)),
+         com.VOIDMETHOD(HRESULT)),
     ]
 
 
 class XA2EngineCallback(com.COMObject):
     _interfaces_ = [IXAudio2EngineCallback]
 
-    def OnProcessingPassStart(self):
-        pass
-
-    def OnProcessingPassEnd(self):
-        pass
-
-    def OnCriticalError(self, this, hresult):
+    def OnCriticalError(self, hresult):
         raise Exception("Critical Error:", hresult)