pyglet 2.1.5__py3-none-any.whl → 2.1.8__py3-none-any.whl

pyglet/libs/x11/xrandr.py

@@ -0,0 +1,166 @@
+import warnings
+from ctypes import c_ulong, c_int, POINTER, Structure, c_char_p, c_uint, c_ushort
+
+import pyglet
+from pyglet.libs.x11.xlib import (
+    Time,
+    Window,
+    Display,
+    XCloseDisplay,
+    XDefaultRootWindow,
+    XOpenDisplay,
+)
+
+lib = None
+try:
+    lib = pyglet.lib.load_library("Xrandr")
+except ImportError:
+    if pyglet.options.debug_lib:
+        warnings.warn("Xrandr could not be loaded.")
+    raise ImportError
+
+RRCrtc      = c_ulong        # typedef XID
+RROutput    = c_ulong        # typedef XID
+RRMode      = c_ulong        # typedef XID
+Connection  = c_ushort       # Connection in Xrandr.h
+SubpixelOrder = c_ushort     # SubpixelOrder in Xrandr.h
+XRRModeFlags = c_ulong
+
+class XRRModeInfo(Structure):
+    _fields_ = [
+        ("id",          RRMode),     # mode ID
+        ("width",       c_uint),   # horizontal resolution
+        ("height",      c_uint),   # vertical resolution
+        ("dotClock",    c_ulong),    # pixel clock (in Hz)
+        ("hSyncStart",  c_uint),
+        ("hSyncEnd",    c_uint),
+        ("hTotal",      c_uint),
+        ("hSkew",       c_uint),
+        ("vSyncStart",  c_uint),
+        ("vSyncEnd",    c_uint),
+        ("vTotal",      c_uint),
+        ("name",        c_char_p),
+        ("nameLength",  c_uint),
+        ("modeFlags",   XRRModeFlags),
+    ]
+
+
+class XRRScreenResources(Structure):
+    _fields_ = [
+        ("timestamp",        Time),
+        ("configTimestamp",  Time),
+        ("ncrtc",            c_int),
+        ("crtcs",            POINTER(RRCrtc)),
+        ("noutput",          c_int),
+        ("outputs",          POINTER(RROutput)),
+        ("nmode",            c_int),
+        ("modes",            POINTER(XRRModeInfo)),
+    ]
+
+
+class XRROutputInfo(Structure):
+    _fields_ = [
+        ("timestamp",      Time),
+        ("crtc",           RRCrtc),
+        ("name",           c_char_p),
+        ("nameLen",        c_int),
+        ("mm_width",       c_ulong),
+        ("mm_height",      c_ulong),
+        ("connection",     Connection),
+        ("subpixel_order", SubpixelOrder),
+        ("ncrtc",          c_int),
+        ("crtcs",          POINTER(RRCrtc)),
+        ("nclone",         c_int),
+        ("clones",         POINTER(RROutput)),
+        ("nmode",          c_int),
+        ("npreferred",     c_int),
+        ("modes",          POINTER(RRMode)),
+    ]
+
+class XRRCrtcInfo(Structure):
+    _fields_ = [
+        ("timestamp",  Time),
+        ("x",          c_int),
+        ("y",          c_int),
+        ("width",      c_uint),
+        ("height",     c_uint),
+        ("mode",       RRMode),
+        ("rotation",   c_int),
+        ("noutput",    c_int),
+        ("outputs",    POINTER(RROutput)),
+        ("rotations",  c_ushort),
+        ("npossible",  c_int),
+        ("possible",   POINTER(RROutput)),
+    ]
+
+
+if lib:
+    XRRQueryVersion = lib.XRRQueryVersion
+    XRRQueryVersion.argtypes = [POINTER(Display), POINTER(c_int), POINTER(c_int)]
+    XRRQueryVersion.restype    = c_int
+
+    XRRGetScreenResources = lib.XRRGetScreenResources
+    XRRGetScreenResources.argtypes = [POINTER(Display), Window]
+    XRRGetScreenResources.restype = POINTER(XRRScreenResources)
+
+    XRRGetOutputPrimary = lib.XRRGetOutputPrimary
+    XRRGetOutputPrimary.argtypes = [POINTER(Display), Window]
+    XRRGetOutputPrimary.restype = RROutput
+
+    XRRGetScreenResourcesCurrent = lib.XRRGetScreenResourcesCurrent
+    XRRGetScreenResourcesCurrent.argtypes = [POINTER(Display), Window]
+    XRRGetScreenResourcesCurrent.restype = POINTER(XRRScreenResources)
+
+    XRRFreeScreenResources = lib.XRRFreeScreenResources
+    XRRFreeScreenResources.argtypes = [POINTER(XRRScreenResources)]
+    XRRFreeScreenResources.restype = None
+
+    XRRGetOutputInfo = lib.XRRGetOutputInfo
+    XRRGetOutputInfo.argtypes = [POINTER(Display), POINTER(XRRScreenResources), RROutput]
+    XRRGetOutputInfo.restype  = POINTER(XRROutputInfo)
+
+    XRRFreeOutputInfo = lib.XRRFreeOutputInfo
+    XRRFreeOutputInfo.argtypes = [POINTER(XRROutputInfo)]
+    XRRFreeOutputInfo.restype = None
+
+    XRRGetCrtcInfo = lib.XRRGetCrtcInfo
+    XRRGetCrtcInfo.argtypes = [POINTER(Display), POINTER(XRRScreenResources), RRCrtc]
+    XRRGetCrtcInfo.restype = POINTER(XRRCrtcInfo)
+
+    XRRSetCrtcConfig = lib.XRRSetCrtcConfig
+    XRRSetCrtcConfig.argtypes = argtypes = [POINTER(Display), POINTER(XRRScreenResources), RRCrtc, Time, c_int, c_int, RRMode, c_int,  POINTER(RROutput), c_int]
+    XRRSetCrtcConfig.restype = c_int
+
+    XRRFreeCrtcInfo = lib.XRRFreeCrtcInfo
+    XRRFreeCrtcInfo.argtypes = [POINTER(XRRCrtcInfo)]
+    XRRFreeCrtcInfo.restype    = None
+
+def list_connected_outputs():
+    dpy = XOpenDisplay(None)
+    if not dpy:
+        raise RuntimeError("Cannot open DISPLAY")
+
+    root = XDefaultRootWindow(dpy)
+    res_p = XRRGetScreenResources(dpy, root)
+    if not res_p:
+        XCloseDisplay(dpy)
+        raise RuntimeError("Failed to get screen resources")
+
+    res = res_p.contents
+    outputs = []
+    for i in range(res.noutput):
+        out_id = res.outputs[i]
+        info_p = XRRGetOutputInfo(dpy, res_p, out_id)
+        if info_p:
+            info = info_p.contents
+            if info.connection == 0:  # Connected.
+                outputs.append(info.name.decode())
+            XRRFreeOutputInfo(info_p)
+
+    XRRFreeScreenResources(res_p)
+    XCloseDisplay(dpy)
+    return outputs
+
+if __name__ == "__main__":
+    for name in list_connected_outputs():
+        print(name)

pyglet/libs/x11/xrender.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import warnings
+from ctypes import Structure, c_ushort, c_ulong, c_int, c_void_p, POINTER
+import pyglet.lib
+from pyglet.libs.x11.xlib import Visual
+
+lib = None
+try:
+    lib = pyglet.lib.load_library("Xrender")
+except ImportError:
+    if pyglet.options.debug_lib:
+        warnings.warn("XRender could not be loaded.")
+
+
+class XRenderDirectFormat(Structure):
+    _fields_ = [
+        ('red', c_ushort),
+        ('redMask', c_ushort),
+        ('green', c_ushort),
+        ('greenMask', c_ushort),
+        ('blue', c_ushort),
+        ('blueMask', c_ushort),
+        ('alpha', c_ushort),
+        ('alphaMask', c_ushort),
+    ]
+
+class XRenderPictFormat(Structure):
+    _fields_ = [
+        ('id', c_ulong),
+        ('type', c_int),
+        ('depth', c_int),
+        ('direct', XRenderDirectFormat),
+        ('colormap', c_ulong),
+    ]
+
+# XRenderFindVisualFormat(Display *dpy, Visual *visual)
+try:
+    XRenderFindVisualFormat = lib.XRenderFindVisualFormat
+    XRenderFindVisualFormat.argtypes = [c_void_p, POINTER(Visual)]
+    XRenderFindVisualFormat.restype = POINTER(XRenderPictFormat)
+except ValueError:
+    XRenderFindVisualFormat = None

pyglet/libs/x11/xsync.py

@@ -406,6 +406,49 @@ XSyncGetPriority = _lib.XSyncGetPriority
 XSyncGetPriority.restype = c_int
 XSyncGetPriority.argtypes = [POINTER(Display), XID, POINTER(c_int)]
 
+# Shape kind
+ShapeBounding = 0
+ShapeClip = 1
+ShapeInput = 2
+
+# Shape operation
+ShapeSet = 0
+ShapeUnion = 1
+ShapeIntersect = 2
+ShapeSubtract = 3
+ShapeInvert = 4
+
+XShapeCombineRegion = _lib.XShapeCombineRegion
+XShapeCombineRegion.argtypes = [
+    POINTER(Display),
+    c_void_p,
+    ctypes.c_int,  # shape kind
+    ctypes.c_int, ctypes.c_int,  # x, y offset
+    c_void_p,
+    ctypes.c_int   # ShapeOp
+]
+
+XShapeCombineMask = _lib.XShapeCombineMask
+XShapeCombineMask.argtypes = [
+    Display,       # *display
+    c_void_p,        # dest window
+    ctypes.c_int,  # shape_kind (e.g., ShapeInput)
+    ctypes.c_int,  # x offset
+    ctypes.c_int,  # y offset
+    ctypes.c_ulong,  # Pixmap (can be 0 for None)
+    ctypes.c_int   # ShapeOp (e.g., ShapeSet)
+]
+XShapeCombineMask.restype = None
+
+XShapeQueryExtension = _lib.XShapeQueryExtension
+XShapeQueryExtension.argtypes = [Display, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)]
+XShapeQueryExtension.restype = Bool
+
+def has_shape_support(display: Display) -> bool:
+    event_base = ctypes.c_int()
+    error_base = ctypes.c_int()
+    return XShapeQueryExtension(display, ctypes.byref(event_base), ctypes.byref(error_base))
+
 
 __all__ = ['SYNC_MAJOR_VERSION', 'SYNC_MINOR_VERSION', 'X_SyncInitialize',
 'X_SyncListSystemCounters', 'X_SyncCreateCounter', 'X_SyncSetCounter',

pyglet/math.py

@@ -191,7 +191,7 @@ class Vec2(_typing.NamedTuple):
             )
 
     def __lt__(self, other: tuple[float, float]) -> bool:
-        return self[0] ** 2 + self[0] ** 2 < other[0] ** 2 + other[1] ** 2
+        return self[0] ** 2 + self[1] ** 2 < other[0] ** 2 + other[1] ** 2
 
     @staticmethod
     def from_heading(heading: float, length: float = 1.0) -> Vec2:
@@ -301,8 +301,7 @@ class Vec2(_typing.NamedTuple):
         This simply means the vector will have a length of 1.0. If the vector
         has a length of 0, the original vector will be returned.
         """
-        d = _math.sqrt(self[0] ** 2 + self[1] ** 2)
-        if d:
+        if d := _math.sqrt(self[0] ** 2 + self[1] ** 2):
             return Vec2(self[0] / d, self[1] / d)
         return self
 
@@ -823,7 +822,8 @@ class Vec4(_typing.NamedTuple):
             )
 
     def __lt__(self, other: Vec4 | tuple[float, float, float, float]) -> bool:
-        return self[0] ** 2 + self[1] ** 2 + self[2] ** 2 < other[0] ** 2 + other[1] ** 2 + other[2] ** 2
+        return (self[0] ** 2 + self[1] ** 2 + self[2] ** 2 + self[3] ** 2 <
+                other[0] ** 2 + other[1] ** 2 + other[2] ** 2 + other[3] ** 2)
 
     def length(self) -> float:
         """Calculate the length of the vector: ``sqrt(x ** 2 + y ** 2 + z ** 2 + w ** 2)``."""
@@ -872,8 +872,7 @@ class Vec4(_typing.NamedTuple):
         This means that the vector will have the same direction, but a length of 1.0.
         If the vector has a length of 0, the original vector will be returned.
         """
-        d = _math.sqrt(self[0] ** 2 + self[1] ** 2 + self[2] ** 2 + self[3] ** 2)
-        if d:
+        if d := _math.sqrt(self[0] ** 2 + self[1] ** 2 + self[2] ** 2 + self[3] ** 2):
             return Vec4(self[0] / d, self[1] / d, self[2] / d, self[3] / d)
         return self
 
@@ -1053,7 +1052,21 @@ class Mat3(_typing.NamedTuple):
     def __matmul__(self, other: Mat3) -> Mat3: ...
 
     def __matmul__(self, other) -> Vec3 | Mat3:
-        if isinstance(other, Vec3):
+        try:
+            # extract the elements in row-column form. (matrix is stored column first)
+            a11, a12, a13, a21, a22, a23, a31, a32, a33 = self
+            b11, b12, b13, b21, b22, b23, b31, b32, b33 = other
+
+            # Multiply and sum rows * columns
+            return Mat3(
+                # Column 1
+                a11 * b11 + a21 * b12 + a31 * b13, a12 * b11 + a22 * b12 + a32 * b13, a13 * b11 + a23 * b12 + a33 * b13,
+                # Column 2
+                a11 * b21 + a21 * b22 + a31 * b23, a12 * b21 + a22 * b22 + a32 * b23, a13 * b21 + a23 * b22 + a33 * b23,
+                # Column 3
+                a11 * b31 + a21 * b32 + a31 * b33, a12 * b31 + a22 * b32 + a32 * b33, a13 * b31 + a23 * b32 + a33 * b33,
+            )
+        except ValueError:
             x, y, z = other
             # extract the elements in row-column form. (matrix is stored column first)
             a11, a12, a13, a21, a22, a23, a31, a32, a33 = self
@@ -1063,24 +1076,6 @@ class Mat3(_typing.NamedTuple):
                 a13 * x + a23 * y + a33 * z,
             )
 
-        if not isinstance(other, Mat3):
-            msg = "Can only multiply with Mat3 or Vec3 types"
-            raise TypeError(msg)
-
-        # extract the elements in row-column form. (matrix is stored column first)
-        a11, a12, a13, a21, a22, a23, a31, a32, a33 = self
-        b11, b12, b13, b21, b22, b23, b31, b32, b33 = other
-
-        # Multiply and sum rows * columns
-        return Mat3(
-            # Column 1
-            a11 * b11 + a21 * b12 + a31 * b13, a12 * b11 + a22 * b12 + a32 * b13, a13 * b11 + a23 * b12 + a33 * b13,
-            # Column 2
-            a11 * b21 + a21 * b22 + a31 * b23, a12 * b21 + a22 * b22 + a32 * b23, a13 * b21 + a23 * b22 + a33 * b23,
-            # Column 3
-            a11 * b31 + a21 * b32 + a31 * b33, a12 * b31 + a22 * b32 + a32 * b33, a13 * b31 + a23 * b32 + a33 * b33,
-        )
-
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}{self[0:3]}\n    {self[3:6]}\n    {self[6:9]}"
 
@@ -1357,7 +1352,26 @@ class Mat4(_typing.NamedTuple):
     def __matmul__(self, other: Mat4) -> Mat4: ...
 
     def __matmul__(self, other):
-        if isinstance(other, Vec4):
+        try:
+            # extract the elements in row-column form. (matrix is stored column first)
+            a11, a12, a13, a14, a21, a22, a23, a24, a31, a32, a33, a34, a41, a42, a43, a44 = self
+            b11, b12, b13, b14, b21, b22, b23, b24, b31, b32, b33, b34, b41, b42, b43, b44 = other
+            # Multiply and sum rows * columns:
+            return Mat4(
+                # Column 1
+                a11 * b11 + a21 * b12 + a31 * b13 + a41 * b14, a12 * b11 + a22 * b12 + a32 * b13 + a42 * b14,
+                a13 * b11 + a23 * b12 + a33 * b13 + a43 * b14, a14 * b11 + a24 * b12 + a34 * b13 + a44 * b14,
+                # Column 2
+                a11 * b21 + a21 * b22 + a31 * b23 + a41 * b24, a12 * b21 + a22 * b22 + a32 * b23 + a42 * b24,
+                a13 * b21 + a23 * b22 + a33 * b23 + a43 * b24, a14 * b21 + a24 * b22 + a34 * b23 + a44 * b24,
+                # Column 3
+                a11 * b31 + a21 * b32 + a31 * b33 + a41 * b34, a12 * b31 + a22 * b32 + a32 * b33 + a42 * b34,
+                a13 * b31 + a23 * b32 + a33 * b33 + a43 * b34, a14 * b31 + a24 * b32 + a34 * b33 + a44 * b34,
+                # Column 4
+                a11 * b41 + a21 * b42 + a31 * b43 + a41 * b44, a12 * b41 + a22 * b42 + a32 * b43 + a42 * b44,
+                a13 * b41 + a23 * b42 + a33 * b43 + a43 * b44, a14 * b41 + a24 * b42 + a34 * b43 + a44 * b44,
+            )
+        except ValueError:
             x, y, z, w = other
             # extract the elements in row-column form. (matrix is stored column first)
             a11, a12, a13, a14, a21, a22, a23, a24, a31, a32, a33, a34, a41, a42, a43, a44 = self
@@ -1368,29 +1382,6 @@ class Mat4(_typing.NamedTuple):
                 x * a14 + y * a24 + z * a34 + w * a44,
             )
 
-        if not isinstance(other, Mat4):
-            msg = "Can only multiply with Mat4 or Vec4 types"
-            raise TypeError(msg)
-
-        # extract the elements in row-column form. (matrix is stored column first)
-        a11, a12, a13, a14, a21, a22, a23, a24, a31, a32, a33, a34, a41, a42, a43, a44 = self
-        b11, b12, b13, b14, b21, b22, b23, b24, b31, b32, b33, b34, b41, b42, b43, b44 = other
-        # Multiply and sum rows * columns:
-        return Mat4(
-            # Column 1
-            a11 * b11 + a21 * b12 + a31 * b13 + a41 * b14, a12 * b11 + a22 * b12 + a32 * b13 + a42 * b14,
-            a13 * b11 + a23 * b12 + a33 * b13 + a43 * b14, a14 * b11 + a24 * b12 + a34 * b13 + a44 * b14,
-            # Column 2
-            a11 * b21 + a21 * b22 + a31 * b23 + a41 * b24, a12 * b21 + a22 * b22 + a32 * b23 + a42 * b24,
-            a13 * b21 + a23 * b22 + a33 * b23 + a43 * b24, a14 * b21 + a24 * b22 + a34 * b23 + a44 * b24,
-            # Column 3
-            a11 * b31 + a21 * b32 + a31 * b33 + a41 * b34, a12 * b31 + a22 * b32 + a32 * b33 + a42 * b34,
-            a13 * b31 + a23 * b32 + a33 * b33 + a43 * b34, a14 * b31 + a24 * b32 + a34 * b33 + a44 * b34,
-            # Column 4
-            a11 * b41 + a21 * b42 + a31 * b43 + a41 * b44, a12 * b41 + a22 * b42 + a32 * b43 + a42 * b44,
-            a13 * b41 + a23 * b42 + a33 * b43 + a43 * b44, a14 * b41 + a24 * b42 + a34 * b43 + a44 * b44,
-        )
-
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}{self[0:4]}\n    {self[4:8]}\n    {self[8:12]}\n    {self[12:16]}"
 

pyglet/media/buffered_logger.py

@@ -1,5 +1,5 @@
 """
-Responsabilities
+Responsibilities
 
     Handles accumulation of debug events while playing media_player and  saves
     when sample's play ends.

pyglet/media/codecs/ffmpeg.py

@@ -126,7 +126,7 @@ class FFmpegException(MediaFormatException):
 def ffmpeg_get_audio_buffer_size(audio_format):
     """Return the audio buffer size
 
-    Buffer size can accomodate 1 sec of audio data.
+    Buffer size can accommodate 1 sec of audio data.
     """
     return audio_format.bytes_per_second + FF_INPUT_BUFFER_PADDING_SIZE
 
@@ -385,16 +385,6 @@ def ffmpeg_stream_info(file: FFmpegFile, stream_index: int) -> StreamAudioInfo |
             context.sample_rate,
             channel_count,
         )
-        if context.format in (AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8P):
-            info.sample_bits = 8
-        elif context.format in (AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
-                                AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP):
-            info.sample_bits = 16
-        elif context.format in (AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P):
-            info.sample_bits = 32
-        else:
-            info.sample_format = None
-            info.sample_bits = None
     else:
         return None
     return info
@@ -466,7 +456,7 @@ def ffmpeg_seek_file(file: FFmpegFile, timestamp: float) -> None:
         buf = create_string_buffer(128)
         avutil.av_strerror(result, buf, 128)
         descr = buf.value
-        raise FFmpegException('Error occured while seeking. ' +
+        raise FFmpegException('Error occurred while seeking. ' +
                               descr.decode())
 
 
@@ -634,35 +624,29 @@ class FFmpegSource(StreamingSource):
                 self._video_stream = stream
                 self._video_stream_index = i
 
-            elif isinstance(info, StreamAudioInfo) and info.sample_bits in (8, 16, 24) and self._audio_stream is None:
+            elif isinstance(info, StreamAudioInfo) and self._audio_stream is None:
                 stream = ffmpeg_open_stream(self._file, i)
 
-                self.audio_format = AudioFormat(
-                    channels=min(2, info.channels),
-                    sample_size=info.sample_bits,
-                    sample_rate=info.sample_rate)
-                self._audio_stream = stream
-                self._audio_stream_index = i
-
-                channel_input = self._get_default_channel_layout(info.channels)
                 channels_out = min(2, info.channels)
+                channel_input = self._get_default_channel_layout(info.channels)
                 channel_output = self._get_default_channel_layout(channels_out)
 
-                sample_rate = stream.codec_context.contents.sample_rate
-                sample_format = stream.codec_context.contents.sample_fmt
-
-                if sample_format in (AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8P):
+                sample_bits = info.sample_bits
+                if info.sample_format in (AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8P):
                     self.tgt_format = AV_SAMPLE_FMT_U8
-                elif sample_format in (AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P):
-                    self.tgt_format = AV_SAMPLE_FMT_S16
-                elif sample_format in (AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P):
-                    self.tgt_format = AV_SAMPLE_FMT_S32
-                elif sample_format in (AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP):
-                    self.tgt_format = AV_SAMPLE_FMT_S16
                 else:
-                    raise FFmpegException('Audio format not supported.')
+                    # No matter the input format, produce S16 samples.
+                    sample_bits = 16
+                    self.tgt_format = AV_SAMPLE_FMT_S16
+
+                self.audio_format = AudioFormat(
+                    channels=channels_out,
+                    sample_size=sample_bits,
+                    sample_rate=info.sample_rate)
+                self._audio_stream = stream
+                self._audio_stream_index = i
 
-                self.audio_convert_ctx = self.get_formatted_swr_context(channel_output, sample_rate, channel_input, sample_format)
+                self.audio_convert_ctx = self.get_formatted_swr_context(channel_output, info.sample_rate, channel_input, info.sample_format)
                 if not self.audio_convert_ctx:
                     swresample.swr_free(self.audio_convert_ctx)
                     raise FFmpegException('Cannot create sample rate converter.')
@@ -676,7 +660,7 @@ class FFmpegSource(StreamingSource):
         self._events = []  # They don't seem to be used!
 
         self.audioq = deque()
-        # Make queue big enough to accomodate 1.2 sec?
+        # Make queue big enough to accommodate 1.2 sec?
         self._max_len_audioq = self.MAX_QUEUE_SIZE  # Need to figure out a correct amount
         if self.audio_format:
              # Buffer 1 sec worth of audio

pyglet/media/codecs/gstreamer.py

@@ -48,7 +48,7 @@ class _MessageHandler:
         """The main message callback"""
         if message.type == Gst.MessageType.EOS:
 
-            self.source.queue.put(self.source.sentinal)
+            self.source.queue.put(self.source.sentinel)
             if not self.source.caps:
                 raise GStreamerDecodeException("Appears to be an unsupported file")
 
@@ -105,7 +105,7 @@ class _MessageHandler:
 class GStreamerSource(StreamingSource):
 
     source_instances = weakref.WeakSet()
-    sentinal = object()
+    sentinel = object()
 
     def __init__(self, filename, file=None):
         self._pipeline = Gst.Pipeline()
@@ -199,7 +199,7 @@ class GStreamerSource(StreamingSource):
         data = bytes()
         while len(data) < num_bytes:
             packet = self.queue.get()
-            if packet == self.sentinal:
+            if packet == self.sentinel:
                 self._finished.set()
                 break
             data += packet

pyglet/media/codecs/pyogg.py

@@ -287,7 +287,7 @@ class MemoryFLACFileStream(UnclosedFLACFileStream):
 
         metadata_status = pyogg.flac.FLAC__stream_decoder_process_until_end_of_metadata(self.decoder)
         if not metadata_status:  # error
-            raise DecodeException("An error occured when trying to decode the metadata of {}".format(path))
+            raise DecodeException("An error occurred when trying to decode the metadata of {}".format(path))
 
     def read_callback(self, decoder, buffer, size, data):
         chunk = size.contents.value

pyglet/media/codecs/wave.py

@@ -25,6 +25,12 @@ class WaveSource(StreamingSource):
 
         nchannels, sampwidth, framerate, nframes, comptype, compname = self._wave.getparams()
 
+        if nchannels not in (1, 2):
+            raise WAVEDecodeException(f"incompatible channel count {nchannels}")
+
+        if sampwidth not in (1, 2):
+            raise WAVEDecodeException(f"incompatible sample width {sampwidth}")
+
         self.audio_format = AudioFormat(channels=nchannels, sample_size=sampwidth * 8, sample_rate=framerate)
 
         self._bytes_per_frame = nchannels * sampwidth

pyglet/media/codecs/wmf.py

@@ -539,19 +539,45 @@ class WMFSource(Source):
             self._source_reader.SetStreamSelection(MF_SOURCE_READER_FIRST_AUDIO_STREAM, True)
 
             # Check sub media type, AKA what kind of codec
-            guid_compressed = com.GUID(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
-            imfmedia.GetGUID(MF_MT_SUBTYPE, byref(guid_compressed))
+            source_subtype_guid = com.GUID(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+            source_sample_size = c_uint32()
+            source_channel_count = c_uint32()
 
-            if guid_compressed == MFAudioFormat_PCM or guid_compressed == MFAudioFormat_Float:
-                assert _debug(f'WMFAudioDecoder: Found Uncompressed Audio: {guid_compressed}')
+            imfmedia.GetGUID(MF_MT_SUBTYPE, byref(source_subtype_guid))
+            try:
+                # Some formats such as mp3 do not report this value
+                imfmedia.GetUINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, byref(source_sample_size))
+            except OSError:
+                source_sample_size.value = 0
+            imfmedia.GetUINT32(MF_MT_AUDIO_NUM_CHANNELS, byref(source_channel_count))
+
+            if (
+                source_subtype_guid == MFAudioFormat_PCM and
+                source_sample_size.value in (8, 16) and
+                source_channel_count.value in (1, 2)
+            ):
+                assert _debug(f'WMFAudioDecoder: Found compatible Integer PCM Audio: {source_subtype_guid}')
             else:
-                assert _debug(f'WMFAudioDecoder: Found Compressed Audio: {guid_compressed}')
-                # If audio is compressed, attempt to decompress it by forcing source reader to use PCM
-                mf_mediatype = IMFMediaType()
+                assert _debug(f'WMFAudioDecoder: Found incompatible Audio: {source_subtype_guid}, '
+                              f'sample size={source_sample_size.value}, channel count={source_channel_count.value}.'
+                              f'Attempting to decode/resample.')
+                # If audio is compressed or incompatible, attempt to decompress or resample it
+                # to standard 16bit integer PCM
+                samples_per_sec = c_uint32()
+                imfmedia.GetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, byref(samples_per_sec))
 
+                channels_out = min(2, source_channel_count.value)
+
+                mf_mediatype = IMFMediaType()
                 MFCreateMediaType(byref(mf_mediatype))
                 mf_mediatype.SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio)
                 mf_mediatype.SetGUID(MF_MT_SUBTYPE, MFAudioFormat_PCM)
+                mf_mediatype.SetUINT32(MF_MT_AUDIO_NUM_CHANNELS, channels_out)
+                mf_mediatype.SetUINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, 16)
+                mf_mediatype.SetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, samples_per_sec.value)
+                mf_mediatype.SetUINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, channels_out * 2)
+                mf_mediatype.SetUINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, samples_per_sec.value * channels_out * 2)
+                mf_mediatype.SetUINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, 1)
 
                 try:
                     self._source_reader.SetCurrentMediaType(self._audio_stream_index, None, mf_mediatype)

pyglet/media/devices/win32.py

@@ -318,7 +318,7 @@ class Win32AudioDeviceManager(base.AbstractAudioDeviceManager):
         return dev_id.value, name, description, state.value
 
     def get_devices(self, flow=eRender, state=DEVICE_STATE_ACTIVE):
-        """Get's all of the specified devices (by default, all output and active)."""
+        """Gets all of the specified devices (by default, all output and active)."""
         collection = IMMDeviceCollection()
         self._device_enum.EnumAudioEndpoints(flow, state, byref(collection))
 

pyglet/media/drivers/base.py

@@ -378,7 +378,7 @@ class AbstractAudioPlayer(metaclass=ABCMeta):
             # Player falling behind
             # Skip at most 12ms if this is a minor desync, otherwise skip the entire
             # difference. this will be noticeable, but the desync is
-            # likely already noticable in context of whatever the application does.
+            # likely already noticeable in context of whatever the application does.
             compensated_bytes = (-desync_bytes
                                  if extreme_desync
                                  else min(-desync_bytes, self.desync_correction_bytes_minor))

pyglet/media/drivers/directsound/interface.py

@@ -5,6 +5,7 @@ import ctypes
 import weakref
 from collections import namedtuple
 
+from pyglet.media.exceptions import MediaException
 from pyglet.util import debug_print
 from pyglet.window.win32 import _user32
 
@@ -20,6 +21,9 @@ def _check(hresult):
 
 
 def _create_wave_format(audio_format):
+    if audio_format.channels > 2 or audio_format.sample_size not in (8, 16):
+        raise MediaException(f'Unsupported audio format: {audio_format}')
+
     wfx = lib.WAVEFORMATEX()
     wfx.wFormatTag = lib.WAVE_FORMAT_PCM
     wfx.nChannels = audio_format.channels

pyglet/media/drivers/listener.py

@@ -53,7 +53,7 @@ class AbstractListener(metaclass=ABCMeta):
         listener is facing.
 
         The orientation is given as a tuple of floats (x, y, z), and has
-        no unit.  The forward orientation should be orthagonal to the
+        no unit.  The forward orientation should be orthogonal to the
         up orientation.
 
         :type: 3-tuple of float
@@ -69,7 +69,7 @@ class AbstractListener(metaclass=ABCMeta):
         of the listener.
 
         The orientation is given as a tuple of floats (x, y, z), and has
-        no unit.  The up orientation should be orthagonal to the
+        no unit.  The up orientation should be orthogonal to the
         forward orientation.
 
         :type: 3-tuple of float