doc_content stringlengths 1 386k | doc_id stringlengths 5 188 |
|---|---|
reflect()
returns a vector reflected of a given normal. reflect(Vector2) -> Vector2 Returns a new vector that points in the direction as if self would bounce of a surface characterized by the given surface normal. The length of the new vector is the same as self's. | pygame.ref.math#pygame.math.Vector2.reflect |
reflect_ip()
reflect the vector of a given normal in place. reflect_ip(Vector2) -> None Changes the direction of self as if it would have been reflected of a surface with the given surface normal. | pygame.ref.math#pygame.math.Vector2.reflect_ip |
rotate()
rotates a vector by a given angle in degrees. rotate(angle) -> Vector2 Returns a vector which has the same length as self but is rotated counterclockwise by the given angle in degrees. | pygame.ref.math#pygame.math.Vector2.rotate |
rotate_ip()
rotates the vector by a given angle in degrees in place. rotate_ip(angle) -> None Rotates the vector counterclockwise by the given angle in degrees. The length of the vector is not changed. | pygame.ref.math#pygame.math.Vector2.rotate_ip |
rotate_ip_rad()
rotates the vector by a given angle in radians in place. rotate_ip_rad(angle) -> None Rotates the vector counterclockwise by the given angle in radians. The length of the vector is not changed. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector2.rotate_ip_rad |
rotate_rad()
rotates a vector by a given angle in radians. rotate_rad(angle) -> Vector2 Returns a vector which has the same length as self but is rotated counterclockwise by the given angle in radians. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector2.rotate_rad |
scale_to_length()
scales the vector to a given length. scale_to_length(float) -> None Scales the vector so that it has the given length. The direction of the vector is not changed. You can also scale to length 0. If the vector is the zero vector (i.e. has length 0 thus no direction) a ValueError is raised. | pygame.ref.math#pygame.math.Vector2.scale_to_length |
slerp()
returns a spherical interpolation to the given vector. slerp(Vector2, float) -> Vector2 Calculates the spherical interpolation from self to the given Vector. The second argument - often called t - must be in the range [-1, 1]. It parametrizes where - in between the two vectors - the result should be. If a negative value is given the interpolation will not take the complement of the shortest path. | pygame.ref.math#pygame.math.Vector2.slerp |
update()
Sets the coordinates of the vector. update() -> None update(int) -> None update(float) -> None update(Vector2) -> None update(x, y) -> None update((x, y)) -> None Sets coordinates x and y in place. New in pygame 1.9.5. | pygame.ref.math#pygame.math.Vector2.update |
pygame.math.Vector3
a 3-Dimensional Vector Vector3() -> Vector3 Vector3(int) -> Vector3 Vector3(float) -> Vector3 Vector3(Vector3) -> Vector3 Vector3(x, y, z) -> Vector3 Vector3((x, y, z)) -> Vector3 Some general information about the Vector3 class. dot()
calculates the dot- or scalar-product with the other vector dot(Vector3) -> float
cross()
calculates the cross- or vector-product cross(Vector3) -> Vector3 calculates the cross-product.
magnitude()
returns the Euclidean magnitude of the vector. magnitude() -> float calculates the magnitude of the vector which follows from the theorem: vec.magnitude() == math.sqrt(vec.x**2 + vec.y**2 + vec.z**2)
magnitude_squared()
returns the squared Euclidean magnitude of the vector. magnitude_squared() -> float calculates the magnitude of the vector which follows from the theorem: vec.magnitude_squared() == vec.x**2 + vec.y**2 + vec.z**2. This is faster than vec.magnitude() because it avoids the square root.
length()
returns the Euclidean length of the vector. length() -> float calculates the Euclidean length of the vector which follows from the Pythagorean theorem: vec.length() == math.sqrt(vec.x**2 + vec.y**2 + vec.z**2)
length_squared()
returns the squared Euclidean length of the vector. length_squared() -> float calculates the Euclidean length of the vector which follows from the Pythagorean theorem: vec.length_squared() == vec.x**2 + vec.y**2 + vec.z**2. This is faster than vec.length() because it avoids the square root.
normalize()
returns a vector with the same direction but length 1. normalize() -> Vector3 Returns a new vector that has length equal to 1 and the same direction as self.
normalize_ip()
normalizes the vector in place so that its length is 1. normalize_ip() -> None Normalizes the vector so that it has length equal to 1. The direction of the vector is not changed.
is_normalized()
tests if the vector is normalized i.e. has length == 1. is_normalized() -> Bool Returns True if the vector has length equal to 1. Otherwise it returns False.
scale_to_length()
scales the vector to a given length. scale_to_length(float) -> None Scales the vector so that it has the given length. The direction of the vector is not changed. You can also scale to length 0. If the vector is the zero vector (i.e. has length 0 thus no direction) a ValueError is raised.
reflect()
returns a vector reflected of a given normal. reflect(Vector3) -> Vector3 Returns a new vector that points in the direction as if self would bounce of a surface characterized by the given surface normal. The length of the new vector is the same as self's.
reflect_ip()
reflect the vector of a given normal in place. reflect_ip(Vector3) -> None Changes the direction of self as if it would have been reflected of a surface with the given surface normal.
distance_to()
calculates the Euclidean distance to a given vector. distance_to(Vector3) -> float
distance_squared_to()
calculates the squared Euclidean distance to a given vector. distance_squared_to(Vector3) -> float
lerp()
returns a linear interpolation to the given vector. lerp(Vector3, float) -> Vector3 Returns a Vector which is a linear interpolation between self and the given Vector. The second parameter determines how far between self an other the result is going to be. It must be a value between 0 and 1, where 0 means self and 1 means other will be returned.
slerp()
returns a spherical interpolation to the given vector. slerp(Vector3, float) -> Vector3 Calculates the spherical interpolation from self to the given Vector. The second argument - often called t - must be in the range [-1, 1]. It parametrizes where - in between the two vectors - the result should be. If a negative value is given the interpolation will not take the complement of the shortest path.
elementwise()
The next operation will be performed elementwise. elementwise() -> VectorElementwiseProxy Applies the following operation to each element of the vector.
rotate()
rotates a vector by a given angle in degrees. rotate(angle, Vector3) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise by the given angle in degrees around the given axis.
rotate_rad()
rotates a vector by a given angle in radians. rotate_rad(angle, Vector3) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise by the given angle in radians around the given axis. New in pygame 2.0.0.
rotate_ip()
rotates the vector by a given angle in degrees in place. rotate_ip(angle, Vector3) -> None Rotates the vector counterclockwise around the given axis by the given angle in degrees. The length of the vector is not changed.
rotate_ip_rad()
rotates the vector by a given angle in radians in place. rotate_ip_rad(angle, Vector3) -> None Rotates the vector counterclockwise around the given axis by the given angle in radians. The length of the vector is not changed. New in pygame 2.0.0.
rotate_x()
rotates a vector around the x-axis by the angle in degrees. rotate_x(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the x-axis by the given angle in degrees.
rotate_x_rad()
rotates a vector around the x-axis by the angle in radians. rotate_x_rad(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the x-axis by the given angle in radians. New in pygame 2.0.0.
rotate_x_ip()
rotates the vector around the x-axis by the angle in degrees in place. rotate_x_ip(angle) -> None Rotates the vector counterclockwise around the x-axis by the given angle in degrees. The length of the vector is not changed.
rotate_x_ip_rad()
rotates the vector around the x-axis by the angle in radians in place. rotate_x_ip_rad(angle) -> None Rotates the vector counterclockwise around the x-axis by the given angle in radians. The length of the vector is not changed. New in pygame 2.0.0.
rotate_y()
rotates a vector around the y-axis by the angle in degrees. rotate_y(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the y-axis by the given angle in degrees.
rotate_y_rad()
rotates a vector around the y-axis by the angle in radians. rotate_y_rad(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the y-axis by the given angle in radians. New in pygame 2.0.0.
rotate_y_ip()
rotates the vector around the y-axis by the angle in degrees in place. rotate_y_ip(angle) -> None Rotates the vector counterclockwise around the y-axis by the given angle in degrees. The length of the vector is not changed.
rotate_y_ip_rad()
rotates the vector around the y-axis by the angle in radians in place. rotate_y_ip_rad(angle) -> None Rotates the vector counterclockwise around the y-axis by the given angle in radians. The length of the vector is not changed. New in pygame 2.0.0.
rotate_z()
rotates a vector around the z-axis by the angle in degrees. rotate_z(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the z-axis by the given angle in degrees.
rotate_z_rad()
rotates a vector around the z-axis by the angle in radians. rotate_z_rad(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the z-axis by the given angle in radians. New in pygame 2.0.0.
rotate_z_ip()
rotates the vector around the z-axis by the angle in degrees in place. rotate_z_ip(angle) -> None Rotates the vector counterclockwise around the z-axis by the given angle in degrees. The length of the vector is not changed.
rotate_z_ip_rad()
rotates the vector around the z-axis by the angle in radians in place. rotate_z_ip_rad(angle) -> None Rotates the vector counterclockwise around the z-axis by the given angle in radians. The length of the vector is not changed.
angle_to()
calculates the angle to a given vector in degrees. angle_to(Vector3) -> float Returns the angle between self and the given vector.
as_spherical()
returns a tuple with radial distance, inclination and azimuthal angle. as_spherical() -> (r, theta, phi) Returns a tuple (r, theta, phi) where r is the radial distance, theta is the inclination angle and phi is the azimuthal angle.
from_spherical()
Sets x, y and z from a spherical coordinates 3-tuple. from_spherical((r, theta, phi)) -> None Sets x, y and z from a tuple (r, theta, phi) where r is the radial distance, theta is the inclination angle and phi is the azimuthal angle.
update()
Sets the coordinates of the vector. update() -> None update(int) -> None update(float) -> None update(Vector3) -> None update(x, y, z) -> None update((x, y, z)) -> None Sets coordinates x, y, and z in place. New in pygame 1.9.5. | pygame.ref.math#pygame.math.Vector3 |
angle_to()
calculates the angle to a given vector in degrees. angle_to(Vector3) -> float Returns the angle between self and the given vector. | pygame.ref.math#pygame.math.Vector3.angle_to |
as_spherical()
returns a tuple with radial distance, inclination and azimuthal angle. as_spherical() -> (r, theta, phi) Returns a tuple (r, theta, phi) where r is the radial distance, theta is the inclination angle and phi is the azimuthal angle. | pygame.ref.math#pygame.math.Vector3.as_spherical |
cross()
calculates the cross- or vector-product cross(Vector3) -> Vector3 calculates the cross-product. | pygame.ref.math#pygame.math.Vector3.cross |
distance_squared_to()
calculates the squared Euclidean distance to a given vector. distance_squared_to(Vector3) -> float | pygame.ref.math#pygame.math.Vector3.distance_squared_to |
distance_to()
calculates the Euclidean distance to a given vector. distance_to(Vector3) -> float | pygame.ref.math#pygame.math.Vector3.distance_to |
dot()
calculates the dot- or scalar-product with the other vector dot(Vector3) -> float | pygame.ref.math#pygame.math.Vector3.dot |
elementwise()
The next operation will be performed elementwise. elementwise() -> VectorElementwiseProxy Applies the following operation to each element of the vector. | pygame.ref.math#pygame.math.Vector3.elementwise |
from_spherical()
Sets x, y and z from a spherical coordinates 3-tuple. from_spherical((r, theta, phi)) -> None Sets x, y and z from a tuple (r, theta, phi) where r is the radial distance, theta is the inclination angle and phi is the azimuthal angle. | pygame.ref.math#pygame.math.Vector3.from_spherical |
is_normalized()
tests if the vector is normalized i.e. has length == 1. is_normalized() -> Bool Returns True if the vector has length equal to 1. Otherwise it returns False. | pygame.ref.math#pygame.math.Vector3.is_normalized |
length()
returns the Euclidean length of the vector. length() -> float calculates the Euclidean length of the vector which follows from the Pythagorean theorem: vec.length() == math.sqrt(vec.x**2 + vec.y**2 + vec.z**2) | pygame.ref.math#pygame.math.Vector3.length |
length_squared()
returns the squared Euclidean length of the vector. length_squared() -> float calculates the Euclidean length of the vector which follows from the Pythagorean theorem: vec.length_squared() == vec.x**2 + vec.y**2 + vec.z**2. This is faster than vec.length() because it avoids the square root. | pygame.ref.math#pygame.math.Vector3.length_squared |
lerp()
returns a linear interpolation to the given vector. lerp(Vector3, float) -> Vector3 Returns a Vector which is a linear interpolation between self and the given Vector. The second parameter determines how far between self an other the result is going to be. It must be a value between 0 and 1, where 0 means self and 1 means other will be returned. | pygame.ref.math#pygame.math.Vector3.lerp |
magnitude()
returns the Euclidean magnitude of the vector. magnitude() -> float calculates the magnitude of the vector which follows from the theorem: vec.magnitude() == math.sqrt(vec.x**2 + vec.y**2 + vec.z**2) | pygame.ref.math#pygame.math.Vector3.magnitude |
magnitude_squared()
returns the squared Euclidean magnitude of the vector. magnitude_squared() -> float calculates the magnitude of the vector which follows from the theorem: vec.magnitude_squared() == vec.x**2 + vec.y**2 + vec.z**2. This is faster than vec.magnitude() because it avoids the square root. | pygame.ref.math#pygame.math.Vector3.magnitude_squared |
normalize()
returns a vector with the same direction but length 1. normalize() -> Vector3 Returns a new vector that has length equal to 1 and the same direction as self. | pygame.ref.math#pygame.math.Vector3.normalize |
normalize_ip()
normalizes the vector in place so that its length is 1. normalize_ip() -> None Normalizes the vector so that it has length equal to 1. The direction of the vector is not changed. | pygame.ref.math#pygame.math.Vector3.normalize_ip |
reflect()
returns a vector reflected of a given normal. reflect(Vector3) -> Vector3 Returns a new vector that points in the direction as if self would bounce of a surface characterized by the given surface normal. The length of the new vector is the same as self's. | pygame.ref.math#pygame.math.Vector3.reflect |
reflect_ip()
reflect the vector of a given normal in place. reflect_ip(Vector3) -> None Changes the direction of self as if it would have been reflected of a surface with the given surface normal. | pygame.ref.math#pygame.math.Vector3.reflect_ip |
rotate()
rotates a vector by a given angle in degrees. rotate(angle, Vector3) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise by the given angle in degrees around the given axis. | pygame.ref.math#pygame.math.Vector3.rotate |
rotate_ip()
rotates the vector by a given angle in degrees in place. rotate_ip(angle, Vector3) -> None Rotates the vector counterclockwise around the given axis by the given angle in degrees. The length of the vector is not changed. | pygame.ref.math#pygame.math.Vector3.rotate_ip |
rotate_ip_rad()
rotates the vector by a given angle in radians in place. rotate_ip_rad(angle, Vector3) -> None Rotates the vector counterclockwise around the given axis by the given angle in radians. The length of the vector is not changed. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector3.rotate_ip_rad |
rotate_rad()
rotates a vector by a given angle in radians. rotate_rad(angle, Vector3) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise by the given angle in radians around the given axis. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector3.rotate_rad |
rotate_x()
rotates a vector around the x-axis by the angle in degrees. rotate_x(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the x-axis by the given angle in degrees. | pygame.ref.math#pygame.math.Vector3.rotate_x |
rotate_x_ip()
rotates the vector around the x-axis by the angle in degrees in place. rotate_x_ip(angle) -> None Rotates the vector counterclockwise around the x-axis by the given angle in degrees. The length of the vector is not changed. | pygame.ref.math#pygame.math.Vector3.rotate_x_ip |
rotate_x_ip_rad()
rotates the vector around the x-axis by the angle in radians in place. rotate_x_ip_rad(angle) -> None Rotates the vector counterclockwise around the x-axis by the given angle in radians. The length of the vector is not changed. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector3.rotate_x_ip_rad |
rotate_x_rad()
rotates a vector around the x-axis by the angle in radians. rotate_x_rad(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the x-axis by the given angle in radians. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector3.rotate_x_rad |
rotate_y()
rotates a vector around the y-axis by the angle in degrees. rotate_y(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the y-axis by the given angle in degrees. | pygame.ref.math#pygame.math.Vector3.rotate_y |
rotate_y_ip()
rotates the vector around the y-axis by the angle in degrees in place. rotate_y_ip(angle) -> None Rotates the vector counterclockwise around the y-axis by the given angle in degrees. The length of the vector is not changed. | pygame.ref.math#pygame.math.Vector3.rotate_y_ip |
rotate_y_ip_rad()
rotates the vector around the y-axis by the angle in radians in place. rotate_y_ip_rad(angle) -> None Rotates the vector counterclockwise around the y-axis by the given angle in radians. The length of the vector is not changed. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector3.rotate_y_ip_rad |
rotate_y_rad()
rotates a vector around the y-axis by the angle in radians. rotate_y_rad(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the y-axis by the given angle in radians. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector3.rotate_y_rad |
rotate_z()
rotates a vector around the z-axis by the angle in degrees. rotate_z(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the z-axis by the given angle in degrees. | pygame.ref.math#pygame.math.Vector3.rotate_z |
rotate_z_ip()
rotates the vector around the z-axis by the angle in degrees in place. rotate_z_ip(angle) -> None Rotates the vector counterclockwise around the z-axis by the given angle in degrees. The length of the vector is not changed. | pygame.ref.math#pygame.math.Vector3.rotate_z_ip |
rotate_z_ip_rad()
rotates the vector around the z-axis by the angle in radians in place. rotate_z_ip_rad(angle) -> None Rotates the vector counterclockwise around the z-axis by the given angle in radians. The length of the vector is not changed. | pygame.ref.math#pygame.math.Vector3.rotate_z_ip_rad |
rotate_z_rad()
rotates a vector around the z-axis by the angle in radians. rotate_z_rad(angle) -> Vector3 Returns a vector which has the same length as self but is rotated counterclockwise around the z-axis by the given angle in radians. New in pygame 2.0.0. | pygame.ref.math#pygame.math.Vector3.rotate_z_rad |
scale_to_length()
scales the vector to a given length. scale_to_length(float) -> None Scales the vector so that it has the given length. The direction of the vector is not changed. You can also scale to length 0. If the vector is the zero vector (i.e. has length 0 thus no direction) a ValueError is raised. | pygame.ref.math#pygame.math.Vector3.scale_to_length |
slerp()
returns a spherical interpolation to the given vector. slerp(Vector3, float) -> Vector3 Calculates the spherical interpolation from self to the given Vector. The second argument - often called t - must be in the range [-1, 1]. It parametrizes where - in between the two vectors - the result should be. If a negative value is given the interpolation will not take the complement of the shortest path. | pygame.ref.math#pygame.math.Vector3.slerp |
update()
Sets the coordinates of the vector. update() -> None update(int) -> None update(float) -> None update(Vector3) -> None update(x, y, z) -> None update((x, y, z)) -> None Sets coordinates x, y, and z in place. New in pygame 1.9.5. | pygame.ref.math#pygame.math.Vector3.update |
pygame.midi
pygame module for interacting with midi input and output. New in pygame 1.9.0. The midi module can send output to midi devices and get input from midi devices. It can also list midi devices on the system. The midi module supports real and virtual midi devices. It uses the portmidi library. Is portable to which ever platforms portmidi supports (currently Windows, Mac OS X, and Linux). This uses pyportmidi for now, but may use its own bindings at some point in the future. The pyportmidi bindings are included with pygame. New in pygame 2.0.0. These are pygame events (pygame.event) reserved for midi use. The MIDIIN event is used by pygame.midi.midis2events() when converting midi events to pygame events. MIDIIN
MIDIOUT pygame.midi.init()
initialize the midi module init() -> None Initializes the pygame.midi module. Must be called before using the pygame.midi module. It is safe to call this more than once.
pygame.midi.quit()
uninitialize the midi module quit() -> None Uninitializes the pygame.midi module. If pygame.midi.init() was called to initialize the pygame.midi module, then this function will be called automatically when your program exits. It is safe to call this function more than once.
pygame.midi.get_init()
returns True if the midi module is currently initialized get_init() -> bool Gets the initialization state of the pygame.midi module.
Returns:
True if the pygame.midi module is currently initialized.
Return type:
bool New in pygame 1.9.5.
pygame.midi.Input
Input is used to get midi input from midi devices. Input(device_id) -> None Input(device_id, buffer_size) -> None
Parameters:
device_id (int) -- midi device id
buffer_size (int) -- (optional) the number of input events to be buffered close()
closes a midi stream, flushing any pending buffers. close() -> None PortMidi attempts to close open streams when the application exits. Note This is particularly difficult under Windows.
poll()
returns True if there's data, or False if not. poll() -> bool Used to indicate if any data exists.
Returns:
True if there is data, False otherwise
Return type:
bool
Raises:
MidiException -- on error
read()
reads num_events midi events from the buffer. read(num_events) -> midi_event_list Reads from the input buffer and gives back midi events.
Parameters:
num_events (int) -- number of input events to read
Returns:
the format for midi_event_list is [[[status, data1, data2, data3], timestamp], ...]
Return type:
list
pygame.midi.Output
Output is used to send midi to an output device Output(device_id) -> None Output(device_id, latency=0) -> None Output(device_id, buffer_size=256) -> None Output(device_id, latency, buffer_size) -> None The buffer_size specifies the number of output events to be buffered waiting for output. In some cases (see below) PortMidi does not buffer output at all and merely passes data to a lower-level API, in which case buffersize is ignored. latency is the delay in milliseconds applied to timestamps to determine when the output should actually occur. If latency is <<0, 0 is assumed. If latency is zero, timestamps are ignored and all output is delivered immediately. If latency is greater than zero, output is delayed until the message timestamp plus the latency. In some cases, PortMidi can obtain better timing than your application by passing timestamps along to the device driver or hardware. Latency may also help you to synchronize midi data to audio data by matching midi latency to the audio buffer latency. Note Time is measured relative to the time source indicated by time_proc. Timestamps are absolute, not relative delays or offsets. abort()
terminates outgoing messages immediately abort() -> None The caller should immediately close the output port; this call may result in transmission of a partial midi message. There is no abort for Midi input because the user can simply ignore messages in the buffer and close an input device at any time.
close()
closes a midi stream, flushing any pending buffers. close() -> None PortMidi attempts to close open streams when the application exits. Note This is particularly difficult under Windows.
note_off()
turns a midi note off (note must be on) note_off(note, velocity=None, channel=0) -> None Turn a note off in the output stream. The note must already be on for this to work correctly.
note_on()
turns a midi note on (note must be off) note_on(note, velocity=None, channel=0) -> None Turn a note on in the output stream. The note must already be off for this to work correctly.
set_instrument()
select an instrument, with a value between 0 and 127 set_instrument(instrument_id, channel=0) -> None Select an instrument.
pitch_bend()
modify the pitch of a channel. set_instrument(value=0, channel=0) -> None Adjust the pitch of a channel. The value is a signed integer from -8192 to +8191. For example, 0 means "no change", +4096 is typically a semitone higher, and -8192 is 1 whole tone lower (though the musical range corresponding to the pitch bend range can also be changed in some synthesizers). If no value is given, the pitch bend is returned to "no change". New in pygame 1.9.4.
write()
writes a list of midi data to the Output write(data) -> None Writes series of MIDI information in the form of a list.
Parameters:
data (list) -- data to write, the expected format is [[[status, data1=0, data2=0, ...], timestamp], ...] with the data# fields being optional
Raises:
IndexError -- if more than 1024 elements in the data list Example: # Program change at time 20000 and 500ms later send note 65 with
# velocity 100.
write([[[0xc0, 0, 0], 20000], [[0x90, 60, 100], 20500]]) Note Timestamps will be ignored if latency = 0 To get a note to play immediately, send MIDI info with timestamp read from function Time Optional data fields: write([[[0xc0, 0, 0], 20000]]) is equivalent to write([[[0xc0], 20000]])
write_short()
writes up to 3 bytes of midi data to the Output write_short(status) -> None write_short(status, data1=0, data2=0) -> None Output MIDI information of 3 bytes or less. The data fields are optional and assumed to be 0 if omitted. Examples of status byte values: 0xc0 # program change
0x90 # note on
# etc. Example: # note 65 on with velocity 100
write_short(0x90, 65, 100)
write_sys_ex()
writes a timestamped system-exclusive midi message. write_sys_ex(when, msg) -> None Writes a timestamped system-exclusive midi message.
Parameters:
msg (list[int] or str) -- midi message
when -- timestamp in milliseconds Example: midi_output.write_sys_ex(0, '\xF0\x7D\x10\x11\x12\x13\xF7')
# is equivalent to
midi_output.write_sys_ex(pygame.midi.time(),
[0xF0, 0x7D, 0x10, 0x11, 0x12, 0x13, 0xF7])
pygame.midi.get_count()
gets the number of devices. get_count() -> num_devices Device ids range from 0 to get_count() - 1
pygame.midi.get_default_input_id()
gets default input device number get_default_input_id() -> default_id The following describes the usage details for this function and the get_default_output_id() function. Return the default device ID or -1 if there are no devices. The result can be passed to the Input/Output class. On a PC the user can specify a default device by setting an environment variable. To use device #1, for example: set PM_RECOMMENDED_INPUT_DEVICE=1
or
set PM_RECOMMENDED_OUTPUT_DEVICE=1 The user should first determine the available device ID by using the supplied application "testin" or "testout". In general, the registry is a better place for this kind of info. With USB devices that can come and go, using integers is not very reliable for device identification. Under Windows, if PM_RECOMMENDED_INPUT_DEVICE (or PM_RECOMMENDED_OUTPUT_DEVICE) is NOT found in the environment, then the default device is obtained by looking for a string in the registry under: HKEY_LOCAL_MACHINE/SOFTWARE/PortMidi/Recommended_Input_Device
or
HKEY_LOCAL_MACHINE/SOFTWARE/PortMidi/Recommended_Output_Device The number of the first device with a substring that matches the string exactly is returned. For example, if the string in the registry is "USB" and device 1 is named "In USB MidiSport 1x1", then that will be the default input because it contains the string "USB". In addition to the name, get_device_info() returns "interf", which is the interface name. The "interface" is the underlying software system or API used by PortMidi to access devices. Supported interfaces: MMSystem # the only Win32 interface currently supported
ALSA # the only Linux interface currently supported
CoreMIDI # the only Mac OS X interface currently supported
# DirectX - not implemented
# OSS - not implemented To specify both the interface and the device name in the registry, separate the two with a comma and a space. The string before the comma must be a substring of the "interf" string and the string after the space must be a substring of the "name" name string in order to match the device. e.g.: MMSystem, In USB MidiSport 1x1 Note In the current release, the default is simply the first device (the input or output device with the lowest PmDeviceID).
pygame.midi.get_default_output_id()
gets default output device number get_default_output_id() -> default_id See get_default_input_id() for usage details.
pygame.midi.get_device_info()
returns information about a midi device get_device_info(an_id) -> (interf, name, input, output, opened) get_device_info(an_id) -> None Gets the device info for a given id.
Parameters:
an_id (int) -- id of the midi device being queried
Returns:
if the id is out of range None is returned, otherwise a tuple of (interf, name, input, output, opened) is returned.
interf: string describing the device interface (e.g. 'ALSA') name: string name of the device (e.g. 'Midi Through Port-0') input: 1 if the device is an input device, otherwise 0 output: 1 if the device is an output device, otherwise 0 opened: 1 if the device is opened, otherwise 0
Return type:
tuple or None
pygame.midi.midis2events()
converts midi events to pygame events midis2events(midi_events, device_id) -> [Event, ...] Takes a sequence of midi events and returns list of pygame events. The midi_events data is expected to be a sequence of ((status, data1, data2, data3), timestamp) midi events (all values required).
Returns:
a list of pygame events of event type MIDIIN
Return type:
list
pygame.midi.time()
returns the current time in ms of the PortMidi timer time() -> time The time is reset to 0 when the pygame.midi module is initialized.
pygame.midi.frequency_to_midi()
Converts a frequency into a MIDI note. Rounds to the closest midi note. frequency_to_midi(midi_note) -> midi_note example: frequency_to_midi(27.5) == 21 New in pygame 1.9.5.
pygame.midi.midi_to_frequency()
Converts a midi note to a frequency. midi_to_frequency(midi_note) -> frequency example: midi_to_frequency(21) == 27.5 New in pygame 1.9.5.
pygame.midi.midi_to_ansi_note()
Returns the Ansi Note name for a midi number. midi_to_ansi_note(midi_note) -> ansi_note example: midi_to_ansi_note(21) == 'A0' New in pygame 1.9.5.
exception pygame.midi.MidiException
exception that pygame.midi functions and classes can raise MidiException(errno) -> None | pygame.ref.midi |
pygame.midi.frequency_to_midi()
Converts a frequency into a MIDI note. Rounds to the closest midi note. frequency_to_midi(midi_note) -> midi_note example: frequency_to_midi(27.5) == 21 New in pygame 1.9.5. | pygame.ref.midi#pygame.midi.frequency_to_midi |
pygame.midi.get_count()
gets the number of devices. get_count() -> num_devices Device ids range from 0 to get_count() - 1 | pygame.ref.midi#pygame.midi.get_count |
pygame.midi.get_default_input_id()
gets default input device number get_default_input_id() -> default_id The following describes the usage details for this function and the get_default_output_id() function. Return the default device ID or -1 if there are no devices. The result can be passed to the Input/Output class. On a PC the user can specify a default device by setting an environment variable. To use device #1, for example: set PM_RECOMMENDED_INPUT_DEVICE=1
or
set PM_RECOMMENDED_OUTPUT_DEVICE=1 The user should first determine the available device ID by using the supplied application "testin" or "testout". In general, the registry is a better place for this kind of info. With USB devices that can come and go, using integers is not very reliable for device identification. Under Windows, if PM_RECOMMENDED_INPUT_DEVICE (or PM_RECOMMENDED_OUTPUT_DEVICE) is NOT found in the environment, then the default device is obtained by looking for a string in the registry under: HKEY_LOCAL_MACHINE/SOFTWARE/PortMidi/Recommended_Input_Device
or
HKEY_LOCAL_MACHINE/SOFTWARE/PortMidi/Recommended_Output_Device The number of the first device with a substring that matches the string exactly is returned. For example, if the string in the registry is "USB" and device 1 is named "In USB MidiSport 1x1", then that will be the default input because it contains the string "USB". In addition to the name, get_device_info() returns "interf", which is the interface name. The "interface" is the underlying software system or API used by PortMidi to access devices. Supported interfaces: MMSystem # the only Win32 interface currently supported
ALSA # the only Linux interface currently supported
CoreMIDI # the only Mac OS X interface currently supported
# DirectX - not implemented
# OSS - not implemented To specify both the interface and the device name in the registry, separate the two with a comma and a space. The string before the comma must be a substring of the "interf" string and the string after the space must be a substring of the "name" name string in order to match the device. e.g.: MMSystem, In USB MidiSport 1x1 Note In the current release, the default is simply the first device (the input or output device with the lowest PmDeviceID). | pygame.ref.midi#pygame.midi.get_default_input_id |
pygame.midi.get_default_output_id()
gets default output device number get_default_output_id() -> default_id See get_default_input_id() for usage details. | pygame.ref.midi#pygame.midi.get_default_output_id |
pygame.midi.get_device_info()
returns information about a midi device get_device_info(an_id) -> (interf, name, input, output, opened) get_device_info(an_id) -> None Gets the device info for a given id.
Parameters:
an_id (int) -- id of the midi device being queried
Returns:
if the id is out of range None is returned, otherwise a tuple of (interf, name, input, output, opened) is returned.
interf: string describing the device interface (e.g. 'ALSA') name: string name of the device (e.g. 'Midi Through Port-0') input: 1 if the device is an input device, otherwise 0 output: 1 if the device is an output device, otherwise 0 opened: 1 if the device is opened, otherwise 0
Return type:
tuple or None | pygame.ref.midi#pygame.midi.get_device_info |
pygame.midi.get_init()
returns True if the midi module is currently initialized get_init() -> bool Gets the initialization state of the pygame.midi module.
Returns:
True if the pygame.midi module is currently initialized.
Return type:
bool New in pygame 1.9.5. | pygame.ref.midi#pygame.midi.get_init |
pygame.midi.init()
initialize the midi module init() -> None Initializes the pygame.midi module. Must be called before using the pygame.midi module. It is safe to call this more than once. | pygame.ref.midi#pygame.midi.init |
pygame.midi.Input
Input is used to get midi input from midi devices. Input(device_id) -> None Input(device_id, buffer_size) -> None
Parameters:
device_id (int) -- midi device id
buffer_size (int) -- (optional) the number of input events to be buffered close()
closes a midi stream, flushing any pending buffers. close() -> None PortMidi attempts to close open streams when the application exits. Note This is particularly difficult under Windows.
poll()
returns True if there's data, or False if not. poll() -> bool Used to indicate if any data exists.
Returns:
True if there is data, False otherwise
Return type:
bool
Raises:
MidiException -- on error
read()
reads num_events midi events from the buffer. read(num_events) -> midi_event_list Reads from the input buffer and gives back midi events.
Parameters:
num_events (int) -- number of input events to read
Returns:
the format for midi_event_list is [[[status, data1, data2, data3], timestamp], ...]
Return type:
list | pygame.ref.midi#pygame.midi.Input |
close()
closes a midi stream, flushing any pending buffers. close() -> None PortMidi attempts to close open streams when the application exits. Note This is particularly difficult under Windows. | pygame.ref.midi#pygame.midi.Input.close |
poll()
returns True if there's data, or False if not. poll() -> bool Used to indicate if any data exists.
Returns:
True if there is data, False otherwise
Return type:
bool
Raises:
MidiException -- on error | pygame.ref.midi#pygame.midi.Input.poll |
read()
reads num_events midi events from the buffer. read(num_events) -> midi_event_list Reads from the input buffer and gives back midi events.
Parameters:
num_events (int) -- number of input events to read
Returns:
the format for midi_event_list is [[[status, data1, data2, data3], timestamp], ...]
Return type:
list | pygame.ref.midi#pygame.midi.Input.read |
pygame.midi.midi_to_ansi_note()
Returns the Ansi Note name for a midi number. midi_to_ansi_note(midi_note) -> ansi_note example: midi_to_ansi_note(21) == 'A0' New in pygame 1.9.5. | pygame.ref.midi#pygame.midi.midi_to_ansi_note |
pygame.midi.midi_to_frequency()
Converts a midi note to a frequency. midi_to_frequency(midi_note) -> frequency example: midi_to_frequency(21) == 27.5 New in pygame 1.9.5. | pygame.ref.midi#pygame.midi.midi_to_frequency |
exception pygame.midi.MidiException
exception that pygame.midi functions and classes can raise MidiException(errno) -> None | pygame.ref.midi#pygame.midi.MidiException |
pygame.midi.midis2events()
converts midi events to pygame events midis2events(midi_events, device_id) -> [Event, ...] Takes a sequence of midi events and returns list of pygame events. The midi_events data is expected to be a sequence of ((status, data1, data2, data3), timestamp) midi events (all values required).
Returns:
a list of pygame events of event type MIDIIN
Return type:
list | pygame.ref.midi#pygame.midi.midis2events |
pygame.midi.Output
Output is used to send midi to an output device Output(device_id) -> None Output(device_id, latency=0) -> None Output(device_id, buffer_size=256) -> None Output(device_id, latency, buffer_size) -> None The buffer_size specifies the number of output events to be buffered waiting for output. In some cases (see below) PortMidi does not buffer output at all and merely passes data to a lower-level API, in which case buffersize is ignored. latency is the delay in milliseconds applied to timestamps to determine when the output should actually occur. If latency is <<0, 0 is assumed. If latency is zero, timestamps are ignored and all output is delivered immediately. If latency is greater than zero, output is delayed until the message timestamp plus the latency. In some cases, PortMidi can obtain better timing than your application by passing timestamps along to the device driver or hardware. Latency may also help you to synchronize midi data to audio data by matching midi latency to the audio buffer latency. Note Time is measured relative to the time source indicated by time_proc. Timestamps are absolute, not relative delays or offsets. abort()
terminates outgoing messages immediately abort() -> None The caller should immediately close the output port; this call may result in transmission of a partial midi message. There is no abort for Midi input because the user can simply ignore messages in the buffer and close an input device at any time.
close()
closes a midi stream, flushing any pending buffers. close() -> None PortMidi attempts to close open streams when the application exits. Note This is particularly difficult under Windows.
note_off()
turns a midi note off (note must be on) note_off(note, velocity=None, channel=0) -> None Turn a note off in the output stream. The note must already be on for this to work correctly.
note_on()
turns a midi note on (note must be off) note_on(note, velocity=None, channel=0) -> None Turn a note on in the output stream. The note must already be off for this to work correctly.
set_instrument()
select an instrument, with a value between 0 and 127 set_instrument(instrument_id, channel=0) -> None Select an instrument.
pitch_bend()
modify the pitch of a channel. set_instrument(value=0, channel=0) -> None Adjust the pitch of a channel. The value is a signed integer from -8192 to +8191. For example, 0 means "no change", +4096 is typically a semitone higher, and -8192 is 1 whole tone lower (though the musical range corresponding to the pitch bend range can also be changed in some synthesizers). If no value is given, the pitch bend is returned to "no change". New in pygame 1.9.4.
write()
writes a list of midi data to the Output write(data) -> None Writes series of MIDI information in the form of a list.
Parameters:
data (list) -- data to write, the expected format is [[[status, data1=0, data2=0, ...], timestamp], ...] with the data# fields being optional
Raises:
IndexError -- if more than 1024 elements in the data list Example: # Program change at time 20000 and 500ms later send note 65 with
# velocity 100.
write([[[0xc0, 0, 0], 20000], [[0x90, 60, 100], 20500]]) Note Timestamps will be ignored if latency = 0 To get a note to play immediately, send MIDI info with timestamp read from function Time Optional data fields: write([[[0xc0, 0, 0], 20000]]) is equivalent to write([[[0xc0], 20000]])
write_short()
writes up to 3 bytes of midi data to the Output write_short(status) -> None write_short(status, data1=0, data2=0) -> None Output MIDI information of 3 bytes or less. The data fields are optional and assumed to be 0 if omitted. Examples of status byte values: 0xc0 # program change
0x90 # note on
# etc. Example: # note 65 on with velocity 100
write_short(0x90, 65, 100)
write_sys_ex()
writes a timestamped system-exclusive midi message. write_sys_ex(when, msg) -> None Writes a timestamped system-exclusive midi message.
Parameters:
msg (list[int] or str) -- midi message
when -- timestamp in milliseconds Example: midi_output.write_sys_ex(0, '\xF0\x7D\x10\x11\x12\x13\xF7')
# is equivalent to
midi_output.write_sys_ex(pygame.midi.time(),
[0xF0, 0x7D, 0x10, 0x11, 0x12, 0x13, 0xF7]) | pygame.ref.midi#pygame.midi.Output |
abort()
terminates outgoing messages immediately abort() -> None The caller should immediately close the output port; this call may result in transmission of a partial midi message. There is no abort for Midi input because the user can simply ignore messages in the buffer and close an input device at any time. | pygame.ref.midi#pygame.midi.Output.abort |
close()
closes a midi stream, flushing any pending buffers. close() -> None PortMidi attempts to close open streams when the application exits. Note This is particularly difficult under Windows. | pygame.ref.midi#pygame.midi.Output.close |
note_off()
turns a midi note off (note must be on) note_off(note, velocity=None, channel=0) -> None Turn a note off in the output stream. The note must already be on for this to work correctly. | pygame.ref.midi#pygame.midi.Output.note_off |
note_on()
turns a midi note on (note must be off) note_on(note, velocity=None, channel=0) -> None Turn a note on in the output stream. The note must already be off for this to work correctly. | pygame.ref.midi#pygame.midi.Output.note_on |
pitch_bend()
modify the pitch of a channel. set_instrument(value=0, channel=0) -> None Adjust the pitch of a channel. The value is a signed integer from -8192 to +8191. For example, 0 means "no change", +4096 is typically a semitone higher, and -8192 is 1 whole tone lower (though the musical range corresponding to the pitch bend range can also be changed in some synthesizers). If no value is given, the pitch bend is returned to "no change". New in pygame 1.9.4. | pygame.ref.midi#pygame.midi.Output.pitch_bend |
set_instrument()
select an instrument, with a value between 0 and 127 set_instrument(instrument_id, channel=0) -> None Select an instrument. | pygame.ref.midi#pygame.midi.Output.set_instrument |
write()
writes a list of midi data to the Output write(data) -> None Writes series of MIDI information in the form of a list.
Parameters:
data (list) -- data to write, the expected format is [[[status, data1=0, data2=0, ...], timestamp], ...] with the data# fields being optional
Raises:
IndexError -- if more than 1024 elements in the data list Example: # Program change at time 20000 and 500ms later send note 65 with
# velocity 100.
write([[[0xc0, 0, 0], 20000], [[0x90, 60, 100], 20500]]) Note Timestamps will be ignored if latency = 0 To get a note to play immediately, send MIDI info with timestamp read from function Time Optional data fields: write([[[0xc0, 0, 0], 20000]]) is equivalent to write([[[0xc0], 20000]]) | pygame.ref.midi#pygame.midi.Output.write |
write_short()
writes up to 3 bytes of midi data to the Output write_short(status) -> None write_short(status, data1=0, data2=0) -> None Output MIDI information of 3 bytes or less. The data fields are optional and assumed to be 0 if omitted. Examples of status byte values: 0xc0 # program change
0x90 # note on
# etc. Example: # note 65 on with velocity 100
write_short(0x90, 65, 100) | pygame.ref.midi#pygame.midi.Output.write_short |
write_sys_ex()
writes a timestamped system-exclusive midi message. write_sys_ex(when, msg) -> None Writes a timestamped system-exclusive midi message.
Parameters:
msg (list[int] or str) -- midi message
when -- timestamp in milliseconds Example: midi_output.write_sys_ex(0, '\xF0\x7D\x10\x11\x12\x13\xF7')
# is equivalent to
midi_output.write_sys_ex(pygame.midi.time(),
[0xF0, 0x7D, 0x10, 0x11, 0x12, 0x13, 0xF7]) | pygame.ref.midi#pygame.midi.Output.write_sys_ex |
pygame.midi.quit()
uninitialize the midi module quit() -> None Uninitializes the pygame.midi module. If pygame.midi.init() was called to initialize the pygame.midi module, then this function will be called automatically when your program exits. It is safe to call this function more than once. | pygame.ref.midi#pygame.midi.quit |
pygame.midi.time()
returns the current time in ms of the PortMidi timer time() -> time The time is reset to 0 when the pygame.midi module is initialized. | pygame.ref.midi#pygame.midi.time |
pygame.mixer
pygame module for loading and playing sounds This module contains classes for loading Sound objects and controlling playback. The mixer module is optional and depends on SDL_mixer. Your program should test that pygame.mixer is available and initialized before using it. The mixer module has a limited number of channels for playback of sounds. Usually programs tell pygame to start playing audio and it selects an available channel automatically. The default is 8 simultaneous channels, but complex programs can get more precise control over the number of channels and their use. All sound playback is mixed in background threads. When you begin to play a Sound object, it will return immediately while the sound continues to play. A single Sound object can also be actively played back multiple times. The mixer also has a special streaming channel. This is for music playback and is accessed through the pygame.mixer.music module. The mixer module must be initialized like other pygame modules, but it has some extra conditions. The pygame.mixer.init() function takes several optional arguments to control the playback rate and sample size. Pygame will default to reasonable values, but pygame cannot perform Sound resampling, so the mixer should be initialized to match the values of your audio resources. NOTE: For less laggy sound use a smaller buffer size. The default is set to reduce the chance of scratchy sounds on some computers. You can change the default buffer by calling pygame.mixer.pre_init() before pygame.mixer.init() or pygame.init() is called. For example: pygame.mixer.pre_init(44100,-16,2, 1024) pygame.mixer.init()
initialize the mixer module init(frequency=44100, size=-16, channels=2, buffer=512, devicename=None, allowedchanges=AUDIO_ALLOW_FREQUENCY_CHANGE | AUDIO_ALLOW_CHANNELS_CHANGE) -> None Initialize the mixer module for Sound loading and playback. The default arguments can be overridden to provide specific audio mixing. Keyword arguments are accepted. For backward compatibility where an argument is set zero the default value is used (possible changed by a pre_init call). The size argument represents how many bits are used for each audio sample. If the value is negative then signed sample values will be used. Positive values mean unsigned audio samples will be used. An invalid value raises an exception. The channels argument is used to specify whether to use mono or stereo. 1 for mono and 2 for stereo. The buffer argument controls the number of internal samples used in the sound mixer. The default value should work for most cases. It can be lowered to reduce latency, but sound dropout may occur. It can be raised to larger values to ensure playback never skips, but it will impose latency on sound playback. The buffer size must be a power of two (if not it is rounded up to the next nearest power of 2). Some platforms require the pygame.mixer module to be initialized after the display modules have initialized. The top level pygame.init() takes care of this automatically, but cannot pass any arguments to the mixer init. To solve this, mixer has a function pygame.mixer.pre_init() to set the proper defaults before the toplevel init is used. When using allowedchanges=0 it will convert the samples at runtime to match what the hardware supports. For example a sound card may not support 16bit sound samples, so instead it will use 8bit samples internally. If AUDIO_ALLOW_FORMAT_CHANGE is supplied, then the requested format will change to the closest that SDL2 supports. Apart from 0, allowedchanged accepts the following constants ORed together:
AUDIO_ALLOW_FREQUENCY_CHANGE AUDIO_ALLOW_FORMAT_CHANGE AUDIO_ALLOW_CHANNELS_CHANGE AUDIO_ALLOW_ANY_CHANGE
It is safe to call this more than once, but after the mixer is initialized you cannot change the playback arguments without first calling pygame.mixer.quit(). Changed in pygame 1.8: The default buffersize was changed from 1024 to 3072. Changed in pygame 1.9.1: The default buffersize was changed from 3072 to 4096. Changed in pygame 2.0.0: The default buffersize was changed from 4096 to 512. The default frequency changed to 44100 from 22050. Changed in pygame 2.0.0: size can be 32 (32bit floats). Changed in pygame 2.0.0: channels can also be 4 or 6. New in pygame 2.0.0: allowedchanges argument added
pygame.mixer.pre_init()
preset the mixer init arguments pre_init(frequency=44100, size=-16, channels=2, buffer=512, devicename=None) -> None Call pre_init to change the defaults used when the real pygame.mixer.init() is called. Keyword arguments are accepted. The best way to set custom mixer playback values is to call pygame.mixer.pre_init() before calling the top level pygame.init(). For backward compatibility argument values of zero are replaced with the startup defaults. Changed in pygame 1.8: The default buffersize was changed from 1024 to 3072. Changed in pygame 1.9.1: The default buffersize was changed from 3072 to 4096. Changed in pygame 2.0.0: The default buffersize was changed from 4096 to 512. The default frequency changed to 44100 from 22050.
pygame.mixer.quit()
uninitialize the mixer quit() -> None This will uninitialize pygame.mixer. All playback will stop and any loaded Sound objects may not be compatible with the mixer if it is reinitialized later.
pygame.mixer.get_init()
test if the mixer is initialized get_init() -> (frequency, format, channels) If the mixer is initialized, this returns the playback arguments it is using. If the mixer has not been initialized this returns None.
pygame.mixer.stop()
stop playback of all sound channels stop() -> None This will stop all playback of all active mixer channels.
pygame.mixer.pause()
temporarily stop playback of all sound channels pause() -> None This will temporarily stop all playback on the active mixer channels. The playback can later be resumed with pygame.mixer.unpause()
pygame.mixer.unpause()
resume paused playback of sound channels unpause() -> None This will resume all active sound channels after they have been paused.
pygame.mixer.fadeout()
fade out the volume on all sounds before stopping fadeout(time) -> None This will fade out the volume on all active channels over the time argument in milliseconds. After the sound is muted the playback will stop.
pygame.mixer.set_num_channels()
set the total number of playback channels set_num_channels(count) -> None Sets the number of available channels for the mixer. The default value is 8. The value can be increased or decreased. If the value is decreased, sounds playing on the truncated channels are stopped.
pygame.mixer.get_num_channels()
get the total number of playback channels get_num_channels() -> count Returns the number of currently active playback channels.
pygame.mixer.set_reserved()
reserve channels from being automatically used set_reserved(count) -> None The mixer can reserve any number of channels that will not be automatically selected for playback by Sounds. If sounds are currently playing on the reserved channels they will not be stopped. This allows the application to reserve a specific number of channels for important sounds that must not be dropped or have a guaranteed channel to play on.
pygame.mixer.find_channel()
find an unused channel find_channel(force=False) -> Channel This will find and return an inactive Channel object. If there are no inactive Channels this function will return None. If there are no inactive channels and the force argument is True, this will find the Channel with the longest running Sound and return it. If the mixer has reserved channels from pygame.mixer.set_reserved() then those channels will not be returned here.
pygame.mixer.get_busy()
test if any sound is being mixed get_busy() -> bool Returns True if the mixer is busy mixing any channels. If the mixer is idle then this return False.
pygame.mixer.get_sdl_mixer_version()
get the mixer's SDL version get_sdl_mixer_version() -> (major, minor, patch) get_sdl_mixer_version(linked=True) -> (major, minor, patch)
Parameters:
linked (bool) -- if True (default) the linked version number is returned, otherwise the compiled version number is returned
Returns:
the mixer's SDL library version number (linked or compiled depending on the linked parameter) as a tuple of 3 integers (major, minor, patch)
Return type:
tuple Note The linked and compile version numbers should be the same. New in pygame 2.0.0.
pygame.mixer.Sound
Create a new Sound object from a file or buffer object Sound(filename) -> Sound Sound(file=filename) -> Sound Sound(buffer) -> Sound Sound(buffer=buffer) -> Sound Sound(object) -> Sound Sound(file=object) -> Sound Sound(array=object) -> Sound Load a new sound buffer from a filename, a python file object or a readable buffer object. Limited resampling will be performed to help the sample match the initialize arguments for the mixer. A Unicode string can only be a file pathname. A Python 2.x string or a Python 3.x bytes object can be either a pathname or a buffer object. Use the 'file' or 'buffer' keywords to avoid ambiguity; otherwise Sound may guess wrong. If the array keyword is used, the object is expected to export a version 3, C level array interface or, for Python 2.6 or later, a new buffer interface (The object is checked for a buffer interface first.) The Sound object represents actual sound sample data. Methods that change the state of the Sound object will the all instances of the Sound playback. A Sound object also exports an array interface, and, for Python 2.6 or later, a new buffer interface. The Sound can be loaded from an OGG audio file or from an uncompressed WAV. Note: The buffer will be copied internally, no data will be shared between it and the Sound object. For now buffer and array support is consistent with sndarray.make_sound for Numeric arrays, in that sample sign and byte order are ignored. This will change, either by correctly handling sign and byte order, or by raising an exception when different. Also, source samples are truncated to fit the audio sample size. This will not change. New in pygame 1.8: pygame.mixer.Sound(buffer) New in pygame 1.9.2: pygame.mixer.Sound keyword arguments and array interface support play()
begin sound playback play(loops=0, maxtime=0, fade_ms=0) -> Channel Begin playback of the Sound (i.e., on the computer's speakers) on an available Channel. This will forcibly select a Channel, so playback may cut off a currently playing sound if necessary. The loops argument controls how many times the sample will be repeated after being played the first time. A value of 5 means that the sound will be played once, then repeated five times, and so is played a total of six times. The default value (zero) means the Sound is not repeated, and so is only played once. If loops is set to -1 the Sound will loop indefinitely (though you can still call stop() to stop it). The maxtime argument can be used to stop playback after a given number of milliseconds. The fade_ms argument will make the sound start playing at 0 volume and fade up to full volume over the time given. The sample may end before the fade-in is complete. This returns the Channel object for the channel that was selected.
stop()
stop sound playback stop() -> None This will stop the playback of this Sound on any active Channels.
fadeout()
stop sound playback after fading out fadeout(time) -> None This will stop playback of the sound after fading it out over the time argument in milliseconds. The Sound will fade and stop on all actively playing channels.
set_volume()
set the playback volume for this Sound set_volume(value) -> None This will set the playback volume (loudness) for this Sound. This will immediately affect the Sound if it is playing. It will also affect any future playback of this Sound.
Parameters:
value (float) -- volume in the range of 0.0 to 1.0 (inclusive) If value < 0.0, the volume will not be changed If value > 1.0, the volume will be set to 1.0
get_volume()
get the playback volume get_volume() -> value Return a value from 0.0 to 1.0 representing the volume for this Sound.
get_num_channels()
count how many times this Sound is playing get_num_channels() -> count Return the number of active channels this sound is playing on.
get_length()
get the length of the Sound get_length() -> seconds Return the length of this Sound in seconds.
get_raw()
return a bytestring copy of the Sound samples. get_raw() -> bytes Return a copy of the Sound object buffer as a bytes (for Python 3.x) or str (for Python 2.x) object. New in pygame 1.9.2.
pygame.mixer.Channel
Create a Channel object for controlling playback Channel(id) -> Channel Return a Channel object for one of the current channels. The id must be a value from 0 to the value of pygame.mixer.get_num_channels(). The Channel object can be used to get fine control over the playback of Sounds. A channel can only playback a single Sound at time. Using channels is entirely optional since pygame can manage them by default. play()
play a Sound on a specific Channel play(Sound, loops=0, maxtime=0, fade_ms=0) -> None This will begin playback of a Sound on a specific Channel. If the Channel is currently playing any other Sound it will be stopped. The loops argument has the same meaning as in Sound.play(): it is the number of times to repeat the sound after the first time. If it is 3, the sound will be played 4 times (the first time, then three more). If loops is -1 then the playback will repeat indefinitely. As in Sound.play(), the maxtime argument can be used to stop playback of the Sound after a given number of milliseconds. As in Sound.play(), the fade_ms argument can be used fade in the sound.
stop()
stop playback on a Channel stop() -> None Stop sound playback on a channel. After playback is stopped the channel becomes available for new Sounds to play on it.
pause()
temporarily stop playback of a channel pause() -> None Temporarily stop the playback of sound on a channel. It can be resumed at a later time with Channel.unpause()
unpause()
resume pause playback of a channel unpause() -> None Resume the playback on a paused channel.
fadeout()
stop playback after fading channel out fadeout(time) -> None Stop playback of a channel after fading out the sound over the given time argument in milliseconds.
set_volume()
set the volume of a playing channel set_volume(value) -> None set_volume(left, right) -> None Set the volume (loudness) of a playing sound. When a channel starts to play its volume value is reset. This only affects the current sound. The value argument is between 0.0 and 1.0. If one argument is passed, it will be the volume of both speakers. If two arguments are passed and the mixer is in stereo mode, the first argument will be the volume of the left speaker and the second will be the volume of the right speaker. (If the second argument is None, the first argument will be the volume of both speakers.) If the channel is playing a Sound on which set_volume() has also been called, both calls are taken into account. For example: sound = pygame.mixer.Sound("s.wav")
channel = s.play() # Sound plays at full volume by default
sound.set_volume(0.9) # Now plays at 90% of full volume.
sound.set_volume(0.6) # Now plays at 60% (previous value replaced).
channel.set_volume(0.5) # Now plays at 30% (0.6 * 0.5).
get_volume()
get the volume of the playing channel get_volume() -> value Return the volume of the channel for the current playing sound. This does not take into account stereo separation used by Channel.set_volume(). The Sound object also has its own volume which is mixed with the channel.
get_busy()
check if the channel is active get_busy() -> bool Returns True if the channel is actively mixing sound. If the channel is idle this returns False.
get_sound()
get the currently playing Sound get_sound() -> Sound Return the actual Sound object currently playing on this channel. If the channel is idle None is returned.
queue()
queue a Sound object to follow the current queue(Sound) -> None When a Sound is queued on a Channel, it will begin playing immediately after the current Sound is finished. Each channel can only have a single Sound queued at a time. The queued Sound will only play if the current playback finished automatically. It is cleared on any other call to Channel.stop() or Channel.play(). If there is no sound actively playing on the Channel then the Sound will begin playing immediately.
get_queue()
return any Sound that is queued get_queue() -> Sound If a Sound is already queued on this channel it will be returned. Once the queued sound begins playback it will no longer be on the queue.
set_endevent()
have the channel send an event when playback stops set_endevent() -> None set_endevent(type) -> None When an endevent is set for a channel, it will send an event to the pygame queue every time a sound finishes playing on that channel (not just the first time). Use pygame.event.get() to retrieve the endevent once it's sent. Note that if you called Sound.play(n) or Channel.play(sound,n), the end event is sent only once: after the sound has been played "n+1" times (see the documentation of Sound.play). If Channel.stop() or Channel.play() is called while the sound was still playing, the event will be posted immediately. The type argument will be the event id sent to the queue. This can be any valid event type, but a good choice would be a value between pygame.locals.USEREVENT and pygame.locals.NUMEVENTS. If no type argument is given then the Channel will stop sending endevents.
get_endevent()
get the event a channel sends when playback stops get_endevent() -> type Returns the event type to be sent every time the Channel finishes playback of a Sound. If there is no endevent the function returns pygame.NOEVENT. | pygame.ref.mixer |
pygame.mixer.Channel
Create a Channel object for controlling playback Channel(id) -> Channel Return a Channel object for one of the current channels. The id must be a value from 0 to the value of pygame.mixer.get_num_channels(). The Channel object can be used to get fine control over the playback of Sounds. A channel can only playback a single Sound at time. Using channels is entirely optional since pygame can manage them by default. play()
play a Sound on a specific Channel play(Sound, loops=0, maxtime=0, fade_ms=0) -> None This will begin playback of a Sound on a specific Channel. If the Channel is currently playing any other Sound it will be stopped. The loops argument has the same meaning as in Sound.play(): it is the number of times to repeat the sound after the first time. If it is 3, the sound will be played 4 times (the first time, then three more). If loops is -1 then the playback will repeat indefinitely. As in Sound.play(), the maxtime argument can be used to stop playback of the Sound after a given number of milliseconds. As in Sound.play(), the fade_ms argument can be used fade in the sound.
stop()
stop playback on a Channel stop() -> None Stop sound playback on a channel. After playback is stopped the channel becomes available for new Sounds to play on it.
pause()
temporarily stop playback of a channel pause() -> None Temporarily stop the playback of sound on a channel. It can be resumed at a later time with Channel.unpause()
unpause()
resume pause playback of a channel unpause() -> None Resume the playback on a paused channel.
fadeout()
stop playback after fading channel out fadeout(time) -> None Stop playback of a channel after fading out the sound over the given time argument in milliseconds.
set_volume()
set the volume of a playing channel set_volume(value) -> None set_volume(left, right) -> None Set the volume (loudness) of a playing sound. When a channel starts to play its volume value is reset. This only affects the current sound. The value argument is between 0.0 and 1.0. If one argument is passed, it will be the volume of both speakers. If two arguments are passed and the mixer is in stereo mode, the first argument will be the volume of the left speaker and the second will be the volume of the right speaker. (If the second argument is None, the first argument will be the volume of both speakers.) If the channel is playing a Sound on which set_volume() has also been called, both calls are taken into account. For example: sound = pygame.mixer.Sound("s.wav")
channel = s.play() # Sound plays at full volume by default
sound.set_volume(0.9) # Now plays at 90% of full volume.
sound.set_volume(0.6) # Now plays at 60% (previous value replaced).
channel.set_volume(0.5) # Now plays at 30% (0.6 * 0.5).
get_volume()
get the volume of the playing channel get_volume() -> value Return the volume of the channel for the current playing sound. This does not take into account stereo separation used by Channel.set_volume(). The Sound object also has its own volume which is mixed with the channel.
get_busy()
check if the channel is active get_busy() -> bool Returns True if the channel is actively mixing sound. If the channel is idle this returns False.
get_sound()
get the currently playing Sound get_sound() -> Sound Return the actual Sound object currently playing on this channel. If the channel is idle None is returned.
queue()
queue a Sound object to follow the current queue(Sound) -> None When a Sound is queued on a Channel, it will begin playing immediately after the current Sound is finished. Each channel can only have a single Sound queued at a time. The queued Sound will only play if the current playback finished automatically. It is cleared on any other call to Channel.stop() or Channel.play(). If there is no sound actively playing on the Channel then the Sound will begin playing immediately.
get_queue()
return any Sound that is queued get_queue() -> Sound If a Sound is already queued on this channel it will be returned. Once the queued sound begins playback it will no longer be on the queue.
set_endevent()
have the channel send an event when playback stops set_endevent() -> None set_endevent(type) -> None When an endevent is set for a channel, it will send an event to the pygame queue every time a sound finishes playing on that channel (not just the first time). Use pygame.event.get() to retrieve the endevent once it's sent. Note that if you called Sound.play(n) or Channel.play(sound,n), the end event is sent only once: after the sound has been played "n+1" times (see the documentation of Sound.play). If Channel.stop() or Channel.play() is called while the sound was still playing, the event will be posted immediately. The type argument will be the event id sent to the queue. This can be any valid event type, but a good choice would be a value between pygame.locals.USEREVENT and pygame.locals.NUMEVENTS. If no type argument is given then the Channel will stop sending endevents.
get_endevent()
get the event a channel sends when playback stops get_endevent() -> type Returns the event type to be sent every time the Channel finishes playback of a Sound. If there is no endevent the function returns pygame.NOEVENT. | pygame.ref.mixer#pygame.mixer.Channel |
fadeout()
stop playback after fading channel out fadeout(time) -> None Stop playback of a channel after fading out the sound over the given time argument in milliseconds. | pygame.ref.mixer#pygame.mixer.Channel.fadeout |
get_busy()
check if the channel is active get_busy() -> bool Returns True if the channel is actively mixing sound. If the channel is idle this returns False. | pygame.ref.mixer#pygame.mixer.Channel.get_busy |
get_endevent()
get the event a channel sends when playback stops get_endevent() -> type Returns the event type to be sent every time the Channel finishes playback of a Sound. If there is no endevent the function returns pygame.NOEVENT. | pygame.ref.mixer#pygame.mixer.Channel.get_endevent |
get_queue()
return any Sound that is queued get_queue() -> Sound If a Sound is already queued on this channel it will be returned. Once the queued sound begins playback it will no longer be on the queue. | pygame.ref.mixer#pygame.mixer.Channel.get_queue |
get_sound()
get the currently playing Sound get_sound() -> Sound Return the actual Sound object currently playing on this channel. If the channel is idle None is returned. | pygame.ref.mixer#pygame.mixer.Channel.get_sound |
get_volume()
get the volume of the playing channel get_volume() -> value Return the volume of the channel for the current playing sound. This does not take into account stereo separation used by Channel.set_volume(). The Sound object also has its own volume which is mixed with the channel. | pygame.ref.mixer#pygame.mixer.Channel.get_volume |
pause()
temporarily stop playback of a channel pause() -> None Temporarily stop the playback of sound on a channel. It can be resumed at a later time with Channel.unpause() | pygame.ref.mixer#pygame.mixer.Channel.pause |
play()
play a Sound on a specific Channel play(Sound, loops=0, maxtime=0, fade_ms=0) -> None This will begin playback of a Sound on a specific Channel. If the Channel is currently playing any other Sound it will be stopped. The loops argument has the same meaning as in Sound.play(): it is the number of times to repeat the sound after the first time. If it is 3, the sound will be played 4 times (the first time, then three more). If loops is -1 then the playback will repeat indefinitely. As in Sound.play(), the maxtime argument can be used to stop playback of the Sound after a given number of milliseconds. As in Sound.play(), the fade_ms argument can be used fade in the sound. | pygame.ref.mixer#pygame.mixer.Channel.play |
queue()
queue a Sound object to follow the current queue(Sound) -> None When a Sound is queued on a Channel, it will begin playing immediately after the current Sound is finished. Each channel can only have a single Sound queued at a time. The queued Sound will only play if the current playback finished automatically. It is cleared on any other call to Channel.stop() or Channel.play(). If there is no sound actively playing on the Channel then the Sound will begin playing immediately. | pygame.ref.mixer#pygame.mixer.Channel.queue |
set_endevent()
have the channel send an event when playback stops set_endevent() -> None set_endevent(type) -> None When an endevent is set for a channel, it will send an event to the pygame queue every time a sound finishes playing on that channel (not just the first time). Use pygame.event.get() to retrieve the endevent once it's sent. Note that if you called Sound.play(n) or Channel.play(sound,n), the end event is sent only once: after the sound has been played "n+1" times (see the documentation of Sound.play). If Channel.stop() or Channel.play() is called while the sound was still playing, the event will be posted immediately. The type argument will be the event id sent to the queue. This can be any valid event type, but a good choice would be a value between pygame.locals.USEREVENT and pygame.locals.NUMEVENTS. If no type argument is given then the Channel will stop sending endevents. | pygame.ref.mixer#pygame.mixer.Channel.set_endevent |
set_volume()
set the volume of a playing channel set_volume(value) -> None set_volume(left, right) -> None Set the volume (loudness) of a playing sound. When a channel starts to play its volume value is reset. This only affects the current sound. The value argument is between 0.0 and 1.0. If one argument is passed, it will be the volume of both speakers. If two arguments are passed and the mixer is in stereo mode, the first argument will be the volume of the left speaker and the second will be the volume of the right speaker. (If the second argument is None, the first argument will be the volume of both speakers.) If the channel is playing a Sound on which set_volume() has also been called, both calls are taken into account. For example: sound = pygame.mixer.Sound("s.wav")
channel = s.play() # Sound plays at full volume by default
sound.set_volume(0.9) # Now plays at 90% of full volume.
sound.set_volume(0.6) # Now plays at 60% (previous value replaced).
channel.set_volume(0.5) # Now plays at 30% (0.6 * 0.5). | pygame.ref.mixer#pygame.mixer.Channel.set_volume |
stop()
stop playback on a Channel stop() -> None Stop sound playback on a channel. After playback is stopped the channel becomes available for new Sounds to play on it. | pygame.ref.mixer#pygame.mixer.Channel.stop |
unpause()
resume pause playback of a channel unpause() -> None Resume the playback on a paused channel. | pygame.ref.mixer#pygame.mixer.Channel.unpause |
pygame.mixer.fadeout()
fade out the volume on all sounds before stopping fadeout(time) -> None This will fade out the volume on all active channels over the time argument in milliseconds. After the sound is muted the playback will stop. | pygame.ref.mixer#pygame.mixer.fadeout |
pygame.mixer.find_channel()
find an unused channel find_channel(force=False) -> Channel This will find and return an inactive Channel object. If there are no inactive Channels this function will return None. If there are no inactive channels and the force argument is True, this will find the Channel with the longest running Sound and return it. If the mixer has reserved channels from pygame.mixer.set_reserved() then those channels will not be returned here. | pygame.ref.mixer#pygame.mixer.find_channel |
pygame.mixer.get_busy()
test if any sound is being mixed get_busy() -> bool Returns True if the mixer is busy mixing any channels. If the mixer is idle then this return False. | pygame.ref.mixer#pygame.mixer.get_busy |
pygame.mixer.get_init()
test if the mixer is initialized get_init() -> (frequency, format, channels) If the mixer is initialized, this returns the playback arguments it is using. If the mixer has not been initialized this returns None. | pygame.ref.mixer#pygame.mixer.get_init |
pygame.mixer.get_num_channels()
get the total number of playback channels get_num_channels() -> count Returns the number of currently active playback channels. | pygame.ref.mixer#pygame.mixer.get_num_channels |
pygame.mixer.get_sdl_mixer_version()
get the mixer's SDL version get_sdl_mixer_version() -> (major, minor, patch) get_sdl_mixer_version(linked=True) -> (major, minor, patch)
Parameters:
linked (bool) -- if True (default) the linked version number is returned, otherwise the compiled version number is returned
Returns:
the mixer's SDL library version number (linked or compiled depending on the linked parameter) as a tuple of 3 integers (major, minor, patch)
Return type:
tuple Note The linked and compile version numbers should be the same. New in pygame 2.0.0. | pygame.ref.mixer#pygame.mixer.get_sdl_mixer_version |
pygame.mixer.init()
initialize the mixer module init(frequency=44100, size=-16, channels=2, buffer=512, devicename=None, allowedchanges=AUDIO_ALLOW_FREQUENCY_CHANGE | AUDIO_ALLOW_CHANNELS_CHANGE) -> None Initialize the mixer module for Sound loading and playback. The default arguments can be overridden to provide specific audio mixing. Keyword arguments are accepted. For backward compatibility where an argument is set zero the default value is used (possible changed by a pre_init call). The size argument represents how many bits are used for each audio sample. If the value is negative then signed sample values will be used. Positive values mean unsigned audio samples will be used. An invalid value raises an exception. The channels argument is used to specify whether to use mono or stereo. 1 for mono and 2 for stereo. The buffer argument controls the number of internal samples used in the sound mixer. The default value should work for most cases. It can be lowered to reduce latency, but sound dropout may occur. It can be raised to larger values to ensure playback never skips, but it will impose latency on sound playback. The buffer size must be a power of two (if not it is rounded up to the next nearest power of 2). Some platforms require the pygame.mixer module to be initialized after the display modules have initialized. The top level pygame.init() takes care of this automatically, but cannot pass any arguments to the mixer init. To solve this, mixer has a function pygame.mixer.pre_init() to set the proper defaults before the toplevel init is used. When using allowedchanges=0 it will convert the samples at runtime to match what the hardware supports. For example a sound card may not support 16bit sound samples, so instead it will use 8bit samples internally. If AUDIO_ALLOW_FORMAT_CHANGE is supplied, then the requested format will change to the closest that SDL2 supports. Apart from 0, allowedchanged accepts the following constants ORed together:
AUDIO_ALLOW_FREQUENCY_CHANGE AUDIO_ALLOW_FORMAT_CHANGE AUDIO_ALLOW_CHANNELS_CHANGE AUDIO_ALLOW_ANY_CHANGE
It is safe to call this more than once, but after the mixer is initialized you cannot change the playback arguments without first calling pygame.mixer.quit(). Changed in pygame 1.8: The default buffersize was changed from 1024 to 3072. Changed in pygame 1.9.1: The default buffersize was changed from 3072 to 4096. Changed in pygame 2.0.0: The default buffersize was changed from 4096 to 512. The default frequency changed to 44100 from 22050. Changed in pygame 2.0.0: size can be 32 (32bit floats). Changed in pygame 2.0.0: channels can also be 4 or 6. New in pygame 2.0.0: allowedchanges argument added | pygame.ref.mixer#pygame.mixer.init |
pygame.mixer.music
pygame module for controlling streamed audio The music module is closely tied to pygame.mixer. Use the music module to control the playback of music in the sound mixer. The difference between the music playback and regular Sound playback is that the music is streamed, and never actually loaded all at once. The mixer system only supports a single music stream at once. Be aware that MP3 support is limited. On some systems an unsupported format can crash the program, e.g. Debian Linux. Consider using OGG instead. pygame.mixer.music.load()
Load a music file for playback load(filename) -> None load(object) -> None This will load a music filename/file object and prepare it for playback. If a music stream is already playing it will be stopped. This does not start the music playing.
pygame.mixer.music.unload()
Unload the currently loaded music to free up resources unload() -> None This closes resources like files for any music that may be loaded. New in pygame 2.0.0.
pygame.mixer.music.play()
Start the playback of the music stream play(loops=0, start=0.0, fade_ms = 0) -> None This will play the loaded music stream. If the music is already playing it will be restarted. loops is an optional integer argument, which is 0 by default, it tells how many times to repeat the music. The music repeats indefinately if this argument is set to -1. start is an optional float argument, which is 0.0 by default, which denotes the position in time, the music starts playing from. The starting position depends on the format of the music played. MP3 and OGG use the position as time in seconds. For mp3s the start time position selected may not be accurate as things like variable bit rate encoding and ID3 tags can throw off the timing calculations. For MOD music it is the pattern order number. Passing a start position will raise a NotImplementedError if the start position cannot be set. fade_ms is an optional integer argument, which is 0 by default, makes the music start playing at 0 volume and fade up to full volume over the given time. The sample may end before the fade-in is complete. Changed in pygame 2.0.0: Added optional fade_ms argument
pygame.mixer.music.rewind()
restart music rewind() -> None Resets playback of the current music to the beginning.
pygame.mixer.music.stop()
stop the music playback stop() -> None Stops the music playback if it is currently playing. It Won't Unload the music.
pygame.mixer.music.pause()
temporarily stop music playback pause() -> None Temporarily stop playback of the music stream. It can be resumed with the pygame.mixer.music.unpause() function.
pygame.mixer.music.unpause()
resume paused music unpause() -> None This will resume the playback of a music stream after it has been paused.
pygame.mixer.music.fadeout()
stop music playback after fading out fadeout(time) -> None Fade out and stop the currently playing music. The time argument denotes the integer milliseconds for which the fading effect is generated. Note, that this function blocks until the music has faded out. Calls to fadeout() and set_volume() will have no effect during this time. If an event was set using set_endevent() it will be called after the music has faded.
pygame.mixer.music.set_volume()
set the music volume set_volume(volume) -> None Set the volume of the music playback. The volume argument is a float between 0.0 and 1.0 that sets volume. When new music is loaded the volume is reset to full volume.
pygame.mixer.music.get_volume()
get the music volume get_volume() -> value Returns the current volume for the mixer. The value will be between 0.0 and 1.0.
pygame.mixer.music.get_busy()
check if the music stream is playing get_busy() -> bool Returns True when the music stream is actively playing. When the music is idle this returns False. In pygame 2.0.1 and above this function returns False when the music is paused. In pygame 1 it returns True when the music is paused. Changed in pygame 2.0.1: Returns False when music paused.
pygame.mixer.music.set_pos()
set position to play from set_pos(pos) -> None This sets the position in the music file where playback will start. The meaning of "pos", a float (or a number that can be converted to a float), depends on the music format. For MOD files, pos is the integer pattern number in the module. For OGG it is the absolute position, in seconds, from the beginning of the sound. For MP3 files, it is the relative position, in seconds, from the current position. For absolute positioning in an MP3 file, first call rewind(). Other file formats are unsupported. Newer versions of SDL_mixer have better positioning support than earlier ones. An SDLError is raised if a particular format does not support positioning. Function set_pos() calls underlining SDL_mixer function Mix_SetMusicPosition. New in pygame 1.9.2.
pygame.mixer.music.get_pos()
get the music play time get_pos() -> time This gets the number of milliseconds that the music has been playing for. The returned time only represents how long the music has been playing; it does not take into account any starting position offsets.
pygame.mixer.music.queue()
queue a sound file to follow the current queue(filename) -> None This will load a sound file and queue it. A queued sound file will begin as soon as the current sound naturally ends. Only one sound can be queued at a time. Queuing a new sound while another sound is queued will result in the new sound becoming the queued sound. Also, if the current sound is ever stopped or changed, the queued sound will be lost. The following example will play music by Bach six times, then play music by Mozart once: pygame.mixer.music.load('bach.ogg')
pygame.mixer.music.play(5) # Plays six times, not five!
pygame.mixer.music.queue('mozart.ogg')
pygame.mixer.music.set_endevent()
have the music send an event when playback stops set_endevent() -> None set_endevent(type) -> None This causes pygame to signal (by means of the event queue) when the music is done playing. The argument determines the type of event that will be queued. The event will be queued every time the music finishes, not just the first time. To stop the event from being queued, call this method with no argument.
pygame.mixer.music.get_endevent()
get the event a channel sends when playback stops get_endevent() -> type Returns the event type to be sent every time the music finishes playback. If there is no endevent the function returns pygame.NOEVENT. | pygame.ref.music |
pygame.mixer.music.fadeout()
stop music playback after fading out fadeout(time) -> None Fade out and stop the currently playing music. The time argument denotes the integer milliseconds for which the fading effect is generated. Note, that this function blocks until the music has faded out. Calls to fadeout() and set_volume() will have no effect during this time. If an event was set using set_endevent() it will be called after the music has faded. | pygame.ref.music#pygame.mixer.music.fadeout |
pygame.mixer.music.get_busy()
check if the music stream is playing get_busy() -> bool Returns True when the music stream is actively playing. When the music is idle this returns False. In pygame 2.0.1 and above this function returns False when the music is paused. In pygame 1 it returns True when the music is paused. Changed in pygame 2.0.1: Returns False when music paused. | pygame.ref.music#pygame.mixer.music.get_busy |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.