@ -29,9 +29,9 @@ DEALINGS IN THE SOFTWARE.
- Our main web socket ( mWS ) sends opcode 4 with a guild ID and channel ID . - Our main web socket ( mWS ) sends opcode 4 with a guild ID and channel ID .
- The mWS receives VOICE_STATE_UPDATE and VOICE_SERVER_UPDATE . - The mWS receives VOICE_STATE_UPDATE and VOICE_SERVER_UPDATE .
- We pull the session_id from VOICE_STATE_UPDATE . - We pull the session_id from VOICE_STATE_UPDATE .
- We pull the token , endpoint and guild _idfrom VOICE_SERVER_UPDATE . - We pull the token , endpoint and server _idfrom VOICE_SERVER_UPDATE .
- Then we initiate the voice web socket ( vWS ) pointing to the endpoint . - Then we initiate the voice web socket ( vWS ) pointing to the endpoint .
- We send opcode 0 with the user_id , guild _id, session_id and token using the vWS . - We send opcode 0 with the user_id , server _id, session_id and token using the vWS .
- The vWS sends back opcode 2 with an ssrc , port , modes ( array ) and hearbeat_interval . - The vWS sends back opcode 2 with an ssrc , port , modes ( array ) and hearbeat_interval .
- We send a UDP discovery packet to endpoint : port and receive our IP and our port in LE . - We send a UDP discovery packet to endpoint : port and receive our IP and our port in LE .
- Then we send our IP and port via vWS with opcode 1. - Then we send our IP and port via vWS with opcode 1.
@ -40,18 +40,10 @@ DEALINGS IN THE SOFTWARE.
""" """
import asyncio import asyncio
import websockets
import socket import socket
import json , time
import logging import logging
import struct import struct
import threading import threading
import subprocess
import shlex
import functools
import datetime
import audioop
import inspect
log = logging . getLogger ( __name__ ) log = logging . getLogger ( __name__ )
@ -62,123 +54,10 @@ except ImportError:
has_nacl = False has_nacl = False
from . import opus from . import opus
from . backoff import ExponentialBackoff
from . gateway import * from . gateway import *
from . errors import ClientException , InvalidArgument , ConnectionClosed from . errors import ClientException , ConnectionClosed
from . player import AudioPlayer , AudioSource
class StreamPlayer ( threading . Thread ) :
def __init__ ( self , stream , encoder , connected , player , after , * * kwargs ) :
threading . Thread . __init__ ( self , * * kwargs )
self . daemon = True
self . buff = stream
self . frame_size = encoder . frame_size
self . player = player
self . _end = threading . Event ( )
self . _resumed = threading . Event ( )
self . _resumed . set ( ) # we are not paused
self . _connected = connected
self . after = after
self . delay = encoder . frame_length / 1000.0
self . _volume = 1.0
self . _current_error = None
if after is not None and not callable ( after ) :
raise TypeError ( ' Expected a callable for the " after " parameter. ' )
def _do_run ( self ) :
self . loops = 0
self . _start = time . time ( )
while not self . _end . is_set ( ) :
# are we paused?
if not self . _resumed . is_set ( ) :
# wait until we aren't
self . _resumed . wait ( )
if not self . _connected . is_set ( ) :
self . stop ( )
break
self . loops + = 1
data = self . buff . read ( self . frame_size )
if self . _volume != 1.0 :
data = audioop . mul ( data , 2 , min ( self . _volume , 2.0 ) )
if len ( data ) != self . frame_size :
self . stop ( )
break
self . player ( data )
next_time = self . _start + self . delay * self . loops
delay = max ( 0 , self . delay + ( next_time - time . time ( ) ) )
time . sleep ( delay )
def run ( self ) :
try :
self . _do_run ( )
except Exception as e :
self . _current_error = e
self . stop ( )
finally :
self . _call_after ( )
def _call_after ( self ) :
if self . after is not None :
try :
arg_count = len ( inspect . signature ( self . after ) . parameters )
except :
# if this ended up happening, a mistake was made.
arg_count = 0
try :
if arg_count == 0 :
self . after ( )
else :
self . after ( self )
except :
pass
def stop ( self ) :
self . _end . set ( )
@property
def error ( self ) :
return self . _current_error
@property
def volume ( self ) :
return self . _volume
@volume . setter
def volume ( self , value ) :
self . _volume = max ( value , 0.0 )
def pause ( self ) :
self . _resumed . clear ( )
def resume ( self ) :
self . loops = 0
self . _start = time . time ( )
self . _resumed . set ( )
def is_playing ( self ) :
return self . _resumed . is_set ( ) and not self . is_done ( )
def is_done ( self ) :
return not self . _connected . is_set ( ) or self . _end . is_set ( )
class ProcessPlayer ( StreamPlayer ) :
def __init__ ( self , process , client , after , * * kwargs ) :
super ( ) . __init__ ( process . stdout , client . encoder ,
client . _connected , client . play_audio , after , * * kwargs )
self . process = process
def run ( self ) :
super ( ) . run ( )
self . process . kill ( )
if self . process . poll ( ) is None :
self . process . communicate ( )
class VoiceClient : class VoiceClient :
""" Represents a Discord voice connection. """ Represents a Discord voice connection.
@ -200,41 +79,42 @@ class VoiceClient:
The voice connection session ID . The voice connection session ID .
token : str token : str
The voice connection token . The voice connection token .
user : : class : ` User `
The user connected to voice .
endpoint : str endpoint : str
The endpoint we are connecting to . The endpoint we are connecting to .
channel : : class : ` Channel ` channel : : class : ` Channel `
The voice channel connected to . The voice channel connected to .
guild : : class : ` Guild `
The guild the voice channel is connected to .
Shorthand for ` ` channel . guild ` ` .
loop loop
The event loop that the voice client is running on . The event loop that the voice client is running on .
""" """
def __init__ ( self , user , main_ws , session_id , channel , data , loop ) : def __init__ ( self , state , timeout , channel ) :
if not has_nacl : if not has_nacl :
raise RuntimeError ( " PyNaCl library needed in order to use voice " ) raise RuntimeError ( " PyNaCl library needed in order to use voice " )
self . user = user
self . main_ws = main_ws
self . channel = channel self . channel = channel
self . session_id = session_id self . main_ws = None
self . loop = loop self . timeout = timeout
self . _connected = asyncio . Event ( loop = self . loop ) self . loop = state . loop
self . token = data . get ( ' token ' ) self . _state = state
self . guild_id = data . get ( ' guild_id ' ) # this will be used in the AudioPlayer thread
self . endpoint = data . get ( ' endpoint ' ) self . _connected = threading . Event ( )
self . _connections = 0
self . sequence = 0 self . sequence = 0
self . timestamp = 0 self . timestamp = 0
self . encoder = opus . Encoder ( 48000 , 2 ) self . _runner = None
log . info ( ' created opus encoder with {0.__dict__} ' . format ( self . encoder ) ) self . _player = None
self . encoder = opus . Encoder ( )
warn_nacl = not has_nacl warn_nacl = not has_nacl
@property @property
def guild ( self ) : def guild ( self ) :
return self . channel . guild """ Optional[:class:`Guild`]: The guild we ' re connected to, if applicable. """
return getattr ( self . channel , ' guild ' , None )
@property
def user ( self ) :
""" :class:`ClientUser`: The user connected to voice (i.e. ourselves). """
return self . _state . user
def checked_add ( self , attr , value , limit ) : def checked_add ( self , attr , value , limit ) :
val = getattr ( self , attr ) val = getattr ( self , attr )
@ -246,56 +126,127 @@ class VoiceClient:
# connection related # connection related
@asyncio . coroutine @asyncio . coroutine
def connect ( self ) : def start_handshake ( self ) :
log . info ( ' voice connection is connecting... ' ) log . info ( ' Starting voice handshake... ' )
self . endpoint = self . endpoint . replace ( ' :80 ' , ' ' )
key_id , key_name = self . channel . _get_voice_client_key ( )
guild_id , channel_id = self . channel . _get_voice_state_pair ( )
state = self . _state
self . main_ws = ws = state . _get_websocket ( guild_id )
self . _connections + = 1
def session_id_found ( data ) :
user_id = data . get ( ' user_id ' , 0 )
_guild_id = data . get ( key_name )
return int ( user_id ) == state . self_id and int ( _guild_id ) == key_id
# register the futures for waiting
session_id_future = ws . wait_for ( ' VOICE_STATE_UPDATE ' , session_id_found )
voice_data_future = ws . wait_for ( ' VOICE_SERVER_UPDATE ' , lambda d : int ( d . get ( key_name , 0 ) ) == key_id )
# request joining
yield from ws . voice_state ( guild_id , channel_id )
try :
session_id_data = yield from asyncio . wait_for ( session_id_future , timeout = self . timeout , loop = self . loop )
data = yield from asyncio . wait_for ( voice_data_future , timeout = self . timeout , loop = state . loop )
except asyncio . TimeoutError as e :
yield from ws . voice_state ( guild_id , None , self_mute = True )
raise e
self . session_id = session_id_data . get ( ' session_id ' )
self . server_id = data . get ( key_name )
self . token = data . get ( ' token ' )
self . endpoint = data . get ( ' endpoint ' , ' ' ) . replace ( ' :80 ' , ' ' )
self . endpoint_ip = socket . gethostbyname ( self . endpoint ) self . endpoint_ip = socket . gethostbyname ( self . endpoint )
self . socket = socket . socket ( socket . AF_INET , socket . SOCK_DGRAM ) self . socket = socket . socket ( socket . AF_INET , socket . SOCK_DGRAM )
self . socket . setblocking ( False ) self . socket . setblocking ( False )
log . info ( ' Voice endpoint found {0.endpoint} (IP: {0.endpoint_ip} ) ' . format ( self ) ) log . info ( ' Voice handshake complete. Endpoint found %s (IP: %s ) ' , self . endpoint , self . endpoint_ip )
@asyncio . coroutine
def terminate_handshake ( self , * , remove = False ) :
guild_id , _ = self . channel . _get_voice_state_pair ( )
yield from self . main_ws . voice_state ( guild_id , None , self_mute = True )
if remove :
key_id , _ = self . channel . _get_voice_client_key ( )
self . _state . _remove_voice_client ( key_id )
@asyncio . coroutine
def _switch_regions ( self ) :
# just reconnect when we're requested to switch voice regions
# signal the reconnect loop
yield from self . ws . close ( 1006 )
@asyncio . coroutine
def connect ( self , * , reconnect = True , _tries = 0 , do_handshake = True ) :
log . info ( ' Connecting to voice... ' )
try :
del self . secret_key
except AttributeError :
pass
if do_handshake :
yield from self . start_handshake ( )
try :
self . ws = yield from DiscordVoiceWebSocket . from_client ( self ) self . ws = yield from DiscordVoiceWebSocket . from_client ( self )
while not self . _connected . is_set ( ) : self . _connected . clear ( )
while not hasattr ( self , ' secret_key ' ) :
yield from self . ws . poll_event ( ) yield from self . ws . poll_event ( )
if hasattr ( self , ' secret_key ' ) :
# we have a secret key, so we don't need to poll
# websocket events anymore
self . _connected . set ( ) self . _connected . set ( )
break except ( ConnectionClosed , asyncio . TimeoutError ) :
if reconnect and _tries < 5 :
log . exception ( ' Failed to connect to voice... Retrying... ' )
yield from asyncio . sleep ( 1 + _tries * 2.0 , loop = self . loop )
yield from self . terminate_handshake ( )
yield from self . connect ( reconnect = reconnect , _tries = _tries + 1 )
else :
raise
self . loop . create_task ( self . poll_voice_ws ( ) ) if self . _runner is None :
self . _runner = self . loop . create_task ( self . poll_voice_ws ( reconnect ) )
@asyncio . coroutine @asyncio . coroutine
def poll_voice_ws ( self ) : def poll_voice_ws ( self , reconnect ) :
""" |coro| backoff = ExponentialBackoff ( )
Reads from the voice websocket while connected . fmt = ' Disconnected from voice... Reconnecting in {:.2f} s. '
""" while True :
while self . _connected . is_set ( ) :
try : try :
yield from self . ws . poll_event ( ) yield from self . ws . poll_event ( )
except ConnectionClosed as e : except ( ConnectionClosed , asyncio . TimeoutError ) as e :
if isinstance ( e , ConnectionClosed ) :
if e . code == 1000 : if e . code == 1000 :
yield from self . disconnect ( )
break break
else :
raise if not reconnect :
yield from self . disconnect ( )
raise e
retry = backoff . delay ( )
log . exception ( fmt . format ( retry ) )
self . _connected . clear ( )
yield from asyncio . sleep ( retry , loop = self . loop )
yield from self . terminate_handshake ( )
yield from self . connect ( reconnect = True )
@asyncio . coroutine @asyncio . coroutine
def disconnect ( self ) : def disconnect ( self ) :
""" |coro| """ |coro|
Disconnects all connections to the voice client . Disconnects all connections to the voice client .
In order to reconnect , you must create another voice client
using : meth : ` Client . join_voice_channel ` .
""" """
if not self . _connected . is_set ( ) : if not self . _connected . is_set ( ) :
return return
self . stop ( )
self . _connected . clear ( ) self . _connected . clear ( )
try : try :
yield from self . ws . close ( ) yield from self . ws . close ( )
yield from self . main_ws . voice_state ( self . guild_id , None , self_mut e= True ) yield from self . terminate_handshake ( remov e= True )
finally : finally :
self . socket . close ( ) self . socket . close ( )
@ -305,25 +256,13 @@ class VoiceClient:
Moves you to a different voice channel . Moves you to a different voice channel .
. . warning : :
: class : ` Object ` instances do not work with this function .
Parameters Parameters
- - - - - - - - - - - - - - - - - - - - - -
channel : : class : ` Channel ` channel : : class : ` abc . Snowflake `
The channel to move to . Must be a voice channel . The channel to move to . Must be a voice channel .
Raises
- - - - - - -
InvalidArgument
Not a voice channel .
""" """
guild_id , _ = self . channel . _get_voice_state_pair ( )
if str ( getattr ( channel , ' type ' , ' text ' ) ) != ' voice ' : yield from self . main_ws . voice_state ( guild_id , channel . id )
raise InvalidArgument ( ' Must be a voice channel. ' )
yield from self . main_ws . voice_state ( self . guild_id , channel . id )
def is_connected ( self ) : def is_connected ( self ) :
""" bool: Indicates if the voice client is connected to voice. """ """ bool: Indicates if the voice client is connected to voice. """
@ -349,319 +288,66 @@ class VoiceClient:
# Encrypt and return the data # Encrypt and return the data
return header + box . encrypt ( bytes ( data ) , bytes ( nonce ) ) . ciphertext return header + box . encrypt ( bytes ( data ) , bytes ( nonce ) ) . ciphertext
def create_ffmpeg_player ( self , filename , * , use_avconv = False , pipe = False , stderr = None , options = None , before_options = None , headers = None , after = None ) : def play ( self , source , * , after = None ) :
""" Creates a stream player for ffmpeg that launches in a separate thread to play """ Plays an :class:`AudioSource`.
audio .
The ffmpeg player launches a subprocess of ` ` ffmpeg ` ` to a specific
filename and then plays that file .
You must have the ffmpeg or avconv executable in your path environment variable
in order for this to work .
The operations that can be done on the player are the same as those in
: meth : ` create_stream_player ` .
Examples
- - - - - - - - - -
Basic usage : : :
voice = yield from client . join_voice_channel ( channel )
player = voice . create_ffmpeg_player ( ' cool.mp3 ' )
player . start ( )
Parameters
- - - - - - - - - - -
filename
The filename that ffmpeg will take and convert to PCM bytes .
If ` ` pipe ` ` is True then this is a file - like object that is
passed to the stdin of ` ` ffmpeg ` ` .
use_avconv : bool
Use ` ` avconv ` ` instead of ` ` ffmpeg ` ` .
pipe : bool
If true , denotes that ` ` filename ` ` parameter will be passed
to the stdin of ffmpeg .
stderr
A file - like object or ` ` subprocess . PIPE ` ` to pass to the Popen
constructor .
options : str
Extra command line flags to pass to ` ` ffmpeg ` ` after the ` ` - i ` ` flag .
before_options : str
Command line flags to pass to ` ` ffmpeg ` ` before the ` ` - i ` ` flag .
headers : dict
HTTP headers dictionary to pass to ` ` - headers ` ` command line option
after : callable
The finalizer that is called after the stream is done being
played . All exceptions the finalizer throws are silently discarded .
Raises
- - - - - - -
ClientException
Popen failed to due to an error in ` ` ffmpeg ` ` or ` ` avconv ` ` .
Returns
- - - - - - - -
StreamPlayer
A stream player with specific operations .
See : meth : ` create_stream_player ` .
"""
command = ' ffmpeg ' if not use_avconv else ' avconv '
input_name = ' - ' if pipe else shlex . quote ( filename )
before_args = " "
if isinstance ( headers , dict ) :
for key , value in headers . items ( ) :
before_args + = " {} : {} \r \n " . format ( key , value )
before_args = ' -headers ' + shlex . quote ( before_args )
if isinstance ( before_options , str ) :
before_args + = ' ' + before_options
cmd = command + ' {} -i {} -f s16le -ar {} -ac {} -loglevel warning '
cmd = cmd . format ( before_args , input_name , self . encoder . sampling_rate , self . encoder . channels )
if isinstance ( options , str ) : The finalizer , ` ` after ` ` is called after the source has been exhausted
cmd = cmd + ' ' + options or an error occurred .
cmd + = ' pipe:1 ' If an error happens while the audio player is running , the exception is
caught and the audio player is then stopped .
stdin = None if not pipe else filename
args = shlex . split ( cmd )
try :
p = subprocess . Popen ( args , stdin = stdin , stdout = subprocess . PIPE , stderr = stderr )
return ProcessPlayer ( p , self , after )
except FileNotFoundError as e :
raise ClientException ( ' ffmpeg/avconv was not found in your PATH environment variable ' ) from e
except subprocess . SubprocessError as e :
raise ClientException ( ' Popen failed: {0.__name__} {1} ' . format ( type ( e ) , str ( e ) ) ) from e
@asyncio . coroutine
def create_ytdl_player ( self , url , * , ytdl_options = None , * * kwargs ) :
""" |coro|
Creates a stream player for youtube or other services that launches
in a separate thread to play the audio .
The player uses the ` ` youtube_dl ` ` python library to get the information
required to get audio from the URL . Since this uses an external library ,
you must install it yourself . You can do so by calling
` ` pip install youtube_dl ` ` .
You must have the ffmpeg or avconv executable in your path environment
variable in order for this to work .
The operations that can be done on the player are the same as those in
: meth : ` create_stream_player ` . The player has been augmented and enhanced
to have some info extracted from the URL . If youtube - dl fails to extract
the information then the attribute is ` ` None ` ` . The ` ` yt ` ` , ` ` url ` ` , and
` ` download_url ` ` attributes are always available .
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Operation | Description |
+ == == == == == == == == == == = + == == == == == == == == == == == == == == == == == == == == == == == == == == == == = +
| player . yt | The ` YoutubeDL < ytdl > ` instance . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . url | The URL that is currently playing . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . download_url | The URL that is currently being downloaded to ffmpeg . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . title | The title of the audio stream . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . description | The description of the audio stream . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . uploader | The uploader of the audio stream . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . upload_date | A datetime . date object of when the stream was uploaded . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . duration | The duration of the audio in seconds . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . likes | How many likes the audio stream has . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . dislikes | How many dislikes the audio stream has . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . is_live | Checks if the audio stream is currently livestreaming . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . views | How many views the audio stream has . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
. . _ytdl : https : / / github . com / rg3 / youtube - dl / blob / master / youtube_dl / YoutubeDL . py #L128-L278
Examples
- - - - - - - - - -
Basic usage : : :
voice = await client . join_voice_channel ( channel )
player = await voice . create_ytdl_player ( ' https://www.youtube.com/watch?v=d62TYemN6MQ ' )
player . start ( )
Parameters Parameters
- - - - - - - - - - - - - - - - - - - - - -
url : str source : : class : ` AudioSource `
The URL that ` ` youtube_dl ` ` will take and download audio to pass The audio source we ' re reading from.
to ` ` ffmpeg ` ` or ` ` avconv ` ` to convert to PCM bytes . after
ytdl_options : dict The finalizer that is called after the stream is exhausted .
A dictionary of options to pass into the ` ` YoutubeDL ` ` instance . All exceptions it throws are silently discarded . This function
See ` the documentation < ytdl > ` _ for more details . must have a single parameter , ` ` error ` ` , that denotes an
\* \* kwargs optional exception that was raised during playing .
The rest of the keyword arguments are forwarded to
: func : ` create_ffmpeg_player ` .
Raises Raises
- - - - - - - - - - - - - -
ClientException ClientException
Popen failure from either ` ` ffmpeg ` ` / ` ` avconv ` ` . Already playing audio or not connected .
TypeError
Returns source is not a : class : ` AudioSource ` or after is not a callable .
- - - - - - - -
StreamPlayer
An augmented StreamPlayer that uses ffmpeg .
See : meth : ` create_stream_player ` for base operations .
""" """
import youtube_dl
use_avconv = kwargs . get ( ' use_avconv ' , False )
opts = {
' format ' : ' webm[abr>0]/bestaudio/best ' ,
' prefer_ffmpeg ' : not use_avconv
}
if ytdl_options is not None and isinstance ( ytdl_options , dict ) :
opts . update ( ytdl_options )
ydl = youtube_dl . YoutubeDL ( opts )
func = functools . partial ( ydl . extract_info , url , download = False )
info = yield from self . loop . run_in_executor ( None , func )
if " entries " in info :
info = info [ ' entries ' ] [ 0 ]
log . info ( ' playing URL {} ' . format ( url ) )
download_url = info [ ' url ' ]
player = self . create_ffmpeg_player ( download_url , * * kwargs )
# set the dynamic attributes from the info extraction
player . download_url = download_url
player . url = url
player . yt = ydl
player . views = info . get ( ' view_count ' )
player . is_live = bool ( info . get ( ' is_live ' ) )
player . likes = info . get ( ' like_count ' )
player . dislikes = info . get ( ' dislike_count ' )
player . duration = info . get ( ' duration ' )
player . uploader = info . get ( ' uploader ' )
is_twitch = ' twitch ' in url
if is_twitch :
# twitch has 'title' and 'description' sort of mixed up.
player . title = info . get ( ' description ' )
player . description = None
else :
player . title = info . get ( ' title ' )
player . description = info . get ( ' description ' )
# upload date handling if not self . _connected :
date = info . get ( ' upload_date ' ) raise ClientException ( ' Not connected to voice. ' )
if date :
try :
date = datetime . datetime . strptime ( date , ' % Y % M %d ' ) . date ( )
except ValueError :
date = None
player . upload_date = date if self . is_playing ( ) :
return player raise ClientException ( ' Already playing audio. ' )
def encoder_options ( self , * , sample_rate , channels = 2 ) : if not isinstance ( source , AudioSource ) :
""" Sets the encoder options for the OpusEncoder. raise TypeError ( ' source must an AudioSource not {0.__class__.__name__} ' . format ( source ) )
Calling this after you create a stream player self . _player = AudioPlayer ( source , self , after = after )
via : meth : ` create_ffmpeg_player ` or : meth : ` create_stream_player ` self . _player . start ( )
has no effect .
Parameters def is_playing ( self ) :
- - - - - - - - - - """ Indicates if we ' re currently playing audio. """
sample_rate : int return self . _player is not None and self . _player . is_playing ( )
Sets the sample rate of the OpusEncoder . The unit is in Hz .
channels : int
Sets the number of channels for the OpusEncoder .
2 for stereo , 1 for mono .
Raises def stop ( self ) :
- - - - - - - """ Stops playing audio. """
InvalidArgument if self . _player :
The values provided are invalid . self . _player . stop ( )
""" self . _player = None
if sample_rate not in ( 8000 , 12000 , 16000 , 24000 , 48000 ) :
raise InvalidArgument ( ' Sample rate out of range. Valid: [8000, 12000, 16000, 24000, 48000] ' )
if channels not in ( 1 , 2 ) :
raise InvalidArgument ( ' Channels must be either 1 or 2. ' )
self . encoder = opus . Encoder ( sample_rate , channels )
log . info ( ' created opus encoder with {0.__dict__} ' . format ( self . encoder ) )
def create_stream_player ( self , stream , * , after = None ) :
""" Creates a stream player that launches in a separate thread to
play audio .
The stream player assumes that ` ` stream . read ` ` is a valid function
that returns a * bytes - like * object .
The finalizer , ` ` after ` ` is called after the stream has been exhausted
or an error occurred ( see below ) .
The following operations are valid on the ` ` StreamPlayer ` ` object :
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Operation | Description |
+ == == == == == == == == == == = + == == == == == == == == == == == == == == == == == == == == == == == == == == = +
| player . start ( ) | Starts the audio stream . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . stop ( ) | Stops the audio stream . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . is_done ( ) | Returns a bool indicating if the stream is done . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . is_playing ( ) | Returns a bool indicating if the stream is playing . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . pause ( ) | Pauses the audio stream . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . resume ( ) | Resumes the audio stream . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . volume | Allows you to set the volume of the stream . 1.0 is |
| | equivalent to 100 % and 0.0 is equal to 0 % . The |
| | maximum the volume can be set to is 2.0 for 200 % . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| player . error | The exception that stopped the player . If no error |
| | happened , then this returns None . |
+ - - - - - - - - - - - - - - - - - - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
The stream must have the same sampling rate as the encoder and the same
number of channels . The defaults are 48000 Hz and 2 channels . You
could change the encoder options by using : meth : ` encoder_options `
but this must be called * * before * * this function .
If an error happens while the player is running , the exception is caught and
the player is then stopped . The caught exception could then be retrieved
via ` ` player . error ` ` \. When the player is stopped in this matter , the
finalizer under ` ` after ` ` is called .
Parameters def pause ( self ) :
- - - - - - - - - - - """ Pauses the audio playing. """
stream if self . _player :
The stream object to read from . self . _player . pause ( )
after
The finalizer that is called after the stream is exhausted .
All exceptions it throws are silently discarded . This function
can have either no parameters or a single parameter taking in the
current player .
Returns def resume ( self ) :
- - - - - - - - """ Resumes the audio playing. """
StreamPlayer if self . _player :
A stream player with the operations noted above . self . _player . resume ( )
"""
return StreamPlayer ( stream , self . encoder , self . _connected , self . play_audio , after )
def play_audio ( self , data , * , encode = True ) : def send_audio_packet ( self , data , * , encode = True ) :
""" Sends an audio packet composed of the data. """ Sends an audio packet composed of the data.
You must be connected to play audio . You must be connected to play audio .
@ -683,13 +369,13 @@ class VoiceClient:
self . checked_add ( ' sequence ' , 1 , 65535 ) self . checked_add ( ' sequence ' , 1 , 65535 )
if encode : if encode :
encoded_data = self . encoder . encode ( data , self . encoder . samples_per_frame ) encoded_data = self . encoder . encode ( data , self . encoder . SAMPLES_PER_FRAME )
else : else :
encoded_data = data encoded_data = data
packet = self . _get_voice_packet ( encoded_data ) packet = self . _get_voice_packet ( encoded_data )
try : try :
sent = self . socket . sendto ( packet , ( self . endpoint_ip , self . voice_port ) ) self . socket . sendto ( packet , ( self . endpoint_ip , self . voice_port ) )
except BlockingIOError : except BlockingIOError :
log . warning ( ' A packet has been dropped (seq: {0.sequence} , timestamp: {0.timestamp} ) ' . format ( self ) ) log . warning ( ' A packet has been dropped (seq: {0.sequence} , timestamp: {0.timestamp} ) ' . format ( self ) )
self . checked_add ( ' timestamp ' , self . encoder . samples_per_frame , 4294967295 ) self . checked_add ( ' timestamp ' , self . encoder . SAMPLES_PER_FRAME , 4294967295 )
Rapptz
8 years ago