mirror of
https://github.com/python/cpython.git
synced 2024-12-12 03:04:15 +08:00
a9c6e0618f
Here we are doing no more than adding the value for Py_mod_multiple_interpreters and using it for stdlib modules. We will start checking for it in gh-104206 (once PyInterpreterState.ceval.own_gil is added in gh-104204).
255 lines
7.0 KiB
C
255 lines
7.0 KiB
C
/* Author: Toby Dickenson <htrd90@zepler.org>
|
|
*
|
|
* Copyright (c) 1999 Toby Dickenson
|
|
*
|
|
* Permission to use this software in any way is granted without
|
|
* fee, provided that the copyright notice above appears in all
|
|
* copies. This software is provided "as is" without any warranty.
|
|
*/
|
|
|
|
/* Modified by Guido van Rossum */
|
|
/* Beep added by Mark Hammond */
|
|
/* Win9X Beep and platform identification added by Uncle Timmy */
|
|
|
|
/* Example:
|
|
|
|
import winsound
|
|
import time
|
|
|
|
# Play wav file
|
|
winsound.PlaySound('c:/windows/media/Chord.wav', winsound.SND_FILENAME)
|
|
|
|
# Play sound from control panel settings
|
|
winsound.PlaySound('SystemQuestion', winsound.SND_ALIAS)
|
|
|
|
# Play wav file from memory
|
|
data=open('c:/windows/media/Chimes.wav',"rb").read()
|
|
winsound.PlaySound(data, winsound.SND_MEMORY)
|
|
|
|
# Start playing the first bit of wav file asynchronously
|
|
winsound.PlaySound('c:/windows/media/Chord.wav',
|
|
winsound.SND_FILENAME|winsound.SND_ASYNC)
|
|
# But don't let it go for too long...
|
|
time.sleep(0.1)
|
|
# ...Before stopping it
|
|
winsound.PlaySound(None, 0)
|
|
*/
|
|
|
|
#include <Python.h>
|
|
#include <windows.h>
|
|
#include <mmsystem.h>
|
|
|
|
PyDoc_STRVAR(sound_module_doc,
|
|
"PlaySound(sound, flags) - play a sound\n"
|
|
"SND_FILENAME - sound is a wav file name\n"
|
|
"SND_ALIAS - sound is a registry sound association name\n"
|
|
"SND_LOOP - Play the sound repeatedly; must also specify SND_ASYNC\n"
|
|
"SND_MEMORY - sound is a memory image of a wav file\n"
|
|
"SND_PURGE - stop all instances of the specified sound\n"
|
|
"SND_ASYNC - PlaySound returns immediately\n"
|
|
"SND_NODEFAULT - Do not play a default beep if the sound can not be found\n"
|
|
"SND_NOSTOP - Do not interrupt any sounds currently playing\n" // Raising RuntimeError if needed
|
|
"SND_NOWAIT - Return immediately if the sound driver is busy\n" // Without any errors
|
|
"\n"
|
|
"Beep(frequency, duration) - Make a beep through the PC speaker.\n"
|
|
"MessageBeep(type) - Call Windows MessageBeep.");
|
|
|
|
/*[clinic input]
|
|
module winsound
|
|
[clinic start generated code]*/
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=a18401142d97b8d5]*/
|
|
|
|
#include "clinic/winsound.c.h"
|
|
|
|
/*[clinic input]
|
|
winsound.PlaySound
|
|
|
|
sound: object
|
|
The sound to play; a filename, data, or None.
|
|
flags: int
|
|
Flag values, ored together. See module documentation.
|
|
|
|
A wrapper around the Windows PlaySound API.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
winsound_PlaySound_impl(PyObject *module, PyObject *sound, int flags)
|
|
/*[clinic end generated code: output=49a0fd16a372ebeb input=c63e1f2d848da2f2]*/
|
|
{
|
|
int ok;
|
|
wchar_t *wsound;
|
|
Py_buffer view = {NULL, NULL};
|
|
|
|
if (sound == Py_None) {
|
|
wsound = NULL;
|
|
} else if (flags & SND_MEMORY) {
|
|
if (flags & SND_ASYNC) {
|
|
/* Sidestep reference counting headache; unfortunately this also
|
|
prevent SND_LOOP from memory. */
|
|
PyErr_SetString(PyExc_RuntimeError,
|
|
"Cannot play asynchronously from memory");
|
|
return NULL;
|
|
}
|
|
if (PyObject_GetBuffer(sound, &view, PyBUF_SIMPLE) < 0) {
|
|
return NULL;
|
|
}
|
|
wsound = (wchar_t *)view.buf;
|
|
} else if (PyBytes_Check(sound)) {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"'sound' must be str, os.PathLike, or None, not '%s'",
|
|
Py_TYPE(sound)->tp_name);
|
|
return NULL;
|
|
} else {
|
|
PyObject *obj = PyOS_FSPath(sound);
|
|
// Either <obj> is unicode/bytes/NULL, or a helpful message
|
|
// has been surfaced to the user about how they gave a non-path.
|
|
if (obj == NULL) return NULL;
|
|
if (PyBytes_Check(obj)) {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"'sound' must resolve to str, not bytes");
|
|
Py_DECREF(obj);
|
|
return NULL;
|
|
}
|
|
wsound = PyUnicode_AsWideCharString(obj, NULL);
|
|
Py_DECREF(obj);
|
|
if (wsound == NULL) return NULL;
|
|
}
|
|
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
ok = PlaySoundW(wsound, NULL, flags);
|
|
Py_END_ALLOW_THREADS
|
|
if (view.obj) {
|
|
PyBuffer_Release(&view);
|
|
} else if (sound != Py_None) {
|
|
PyMem_Free(wsound);
|
|
}
|
|
if (!ok) {
|
|
PyErr_SetString(PyExc_RuntimeError, "Failed to play sound");
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
winsound.Beep
|
|
|
|
frequency: int
|
|
Frequency of the sound in hertz.
|
|
Must be in the range 37 through 32,767.
|
|
duration: int
|
|
How long the sound should play, in milliseconds.
|
|
|
|
A wrapper around the Windows Beep API.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
winsound_Beep_impl(PyObject *module, int frequency, int duration)
|
|
/*[clinic end generated code: output=f32382e52ee9b2fb input=40e360cfa00a5cf0]*/
|
|
{
|
|
BOOL ok;
|
|
|
|
if (frequency < 37 || frequency > 32767) {
|
|
PyErr_SetString(PyExc_ValueError,
|
|
"frequency must be in 37 thru 32767");
|
|
return NULL;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
ok = Beep(frequency, duration);
|
|
Py_END_ALLOW_THREADS
|
|
if (!ok) {
|
|
PyErr_SetString(PyExc_RuntimeError,"Failed to beep");
|
|
return NULL;
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
winsound.MessageBeep
|
|
|
|
type: int(c_default="MB_OK") = MB_OK
|
|
|
|
Call Windows MessageBeep(x).
|
|
|
|
x defaults to MB_OK.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
winsound_MessageBeep_impl(PyObject *module, int type)
|
|
/*[clinic end generated code: output=120875455121121f input=db185f741ae21401]*/
|
|
{
|
|
BOOL ok;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
ok = MessageBeep(type);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (!ok) {
|
|
PyErr_SetExcFromWindowsErr(PyExc_RuntimeError, 0);
|
|
return NULL;
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static struct PyMethodDef sound_methods[] =
|
|
{
|
|
WINSOUND_PLAYSOUND_METHODDEF
|
|
WINSOUND_BEEP_METHODDEF
|
|
WINSOUND_MESSAGEBEEP_METHODDEF
|
|
{NULL, NULL}
|
|
};
|
|
|
|
#define ADD_DEFINE(CONST) do { \
|
|
if (PyModule_AddIntConstant(module, #CONST, CONST) < 0) { \
|
|
return -1; \
|
|
} \
|
|
} while (0)
|
|
|
|
static int
|
|
exec_module(PyObject *module)
|
|
{
|
|
ADD_DEFINE(SND_ASYNC);
|
|
ADD_DEFINE(SND_NODEFAULT);
|
|
ADD_DEFINE(SND_NOSTOP);
|
|
ADD_DEFINE(SND_NOWAIT);
|
|
ADD_DEFINE(SND_ALIAS);
|
|
ADD_DEFINE(SND_FILENAME);
|
|
ADD_DEFINE(SND_MEMORY);
|
|
ADD_DEFINE(SND_PURGE);
|
|
ADD_DEFINE(SND_LOOP);
|
|
ADD_DEFINE(SND_APPLICATION);
|
|
|
|
ADD_DEFINE(MB_OK);
|
|
ADD_DEFINE(MB_ICONASTERISK);
|
|
ADD_DEFINE(MB_ICONEXCLAMATION);
|
|
ADD_DEFINE(MB_ICONHAND);
|
|
ADD_DEFINE(MB_ICONQUESTION);
|
|
|
|
#undef ADD_DEFINE
|
|
|
|
return 0;
|
|
}
|
|
|
|
static PyModuleDef_Slot sound_slots[] = {
|
|
{Py_mod_exec, exec_module},
|
|
{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
|
|
{0, NULL}
|
|
};
|
|
|
|
static struct PyModuleDef winsoundmodule = {
|
|
.m_base = PyModuleDef_HEAD_INIT,
|
|
.m_name = "winsound",
|
|
.m_doc = sound_module_doc,
|
|
.m_methods = sound_methods,
|
|
.m_slots = sound_slots,
|
|
};
|
|
|
|
PyMODINIT_FUNC
|
|
PyInit_winsound(void)
|
|
{
|
|
return PyModuleDef_Init(&winsoundmodule);
|
|
}
|