def open(self, url, quality):
"""Attempt to open stream from *url*.
Exits with '-1' (using self.exit()) in case of error, including
an error msg.
"""
self.original_url = url
try:
self.livestreamer = Livestreamer()
self._load_config()
streams = self.livestreamer.streams(url)
except NoPluginError:
self.exit(
"Livestreamer is unable to handle the URL '{}'".format(url))
except PluginError as err:
self.exit("Plugin error: {}".format(err))
if quality not in streams:
print("Unable to find '{}' stream on URL '{}'".format(
quality, url),
file=sys.stderr)
self.exit("List of available streams: {}".format(
sorted(streams.keys())))
self.stream = streams[quality]
try:
self.fd = self.stream.open()
except StreamError as err:
self.exit("Failed to open stream: {}".format(err))
def GetYoutubeFullLink(url): from livestreamer import Livestreamer livestr = Livestreamer() channel = livestr.resolve_url(url) streams = channel.get_streams() stream = streams["best"] return stream.url
def __init__(self):
self.gchoice = -1
self.cchoice = -1
self.exit_now = False
self.state = 'none'
self.keybingings = {
ord('q'): self.quit,
ord('f'): self.get_favorites,
ord('s'): self.get_fav_games,
ord('g'): self.get_games,
ord('n'): self.get_next,
ord('r'): self.refresh,
ord('p'): self.get_previous
}
self.games = []
self.favs = []
self.channels = []
self.twitch = Twitch(config.get('settings', 'twitchapiurl'),
config.get('settings', 'channel'),
config.get('settings', 'game'))
self.livestreamer = Livestreamer()
try:
self.run()
except Exception as e:
print e.message
def stream(videoServerUrl, model):
session = Livestreamer()
session.set_option('http-headers',
'referer=https://bongacams.com/%s' % model)
url = 'hlsvariant://https:%s/hls/stream_%s/playlist.m3u8' % (
videoServerUrl, model)
streams = session.streams(url)
stream = streams['best']
fd = stream.open()
now = datetime.datetime.now()
filePath = '%s/%s.mp4' % (model, model + now.strftime('%Y-%m-%d-%H-%M'))
print(' - Start record stream')
if not os.path.exists(model):
os.makedirs(model)
with open(filePath, 'wb') as f:
while True:
try:
data = fd.read(1024)
f.write(data)
except:
print(' - Error write record into file')
f.close()
return
def GetYoutubeFullLink(url):
from livestreamer import Livestreamer
livestr = Livestreamer()
channel = livestr.resolve_url(url)
streams = channel.get_streams()
stream = streams["best"]
return stream.url
def startRecording(model):
try:
session = Livestreamer()
url = get.stream(model)
if url == 'Offline':
return
recording.append(model.lower())
streams = session.streams("hlsvariant://" + url)
stream = streams["best"]
fd = stream.open()
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime("%Y%m%d_%H%M%S")
file_path = "{path}/{model}/{st}-{model}.mp4".format(
path=settings['save_directory'], model=model, st=st)
directory = file_path.rsplit('/', 1)[0] + '/'
if not os.path.exists(directory):
os.makedirs(directory)
with open(file_path, 'wb') as f:
while True:
try:
data = fd.read(1024)
f.write(data)
except:
break
finally:
os.system('rclone move "{}" milo:milo/b/MFC/"{}"'.format(
file_Path, model))
if model.lower() in recording:
recording.remove(model.lower())
if settings['post_processing_command']:
processing_queue.put({'model': model, 'path': file_path})
def startRecording(model, link):
session = Livestreamer()
streams = session.streams("hls://http://transcode.k8s-do.naked.com/hls/" +
link + "/index.m3u8")
stream = streams["best"]
fd = stream.open()
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime("%Y.%m.%d_%H.%M.%S")
if not os.path.exists("{path}/{model}".format(path=save_directory,
model=model)):
os.makedirs("{path}/{model}".format(path=save_directory, model=model))
with open(
"{path}/{model}/{st}_{model}.mp4".format(path=save_directory,
model=model,
st=st), 'wb') as f:
recording.append(model.lower())
while True:
try:
data = fd.read(1024)
f.write(data)
except:
recording.remove(model)
f.close()
return ()
class TestPluginStream(unittest.TestCase):
def setUp(self):
self.session = Livestreamer()
def assertDictHas(self, a, b):
for key, value in a.items():
self.assertEqual(b[key], value)
def _test_akamaihd(self, surl, host, streamname):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, AkamaiHDStream))
self.assertEqual(stream.host, host)
self.assertEqual(stream.streamname, streamname)
def _test_hls(self, surl, url):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, HLSStream))
self.assertEqual(stream.url, url)
def _test_rtmp(self, surl, url, params):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, RTMPStream))
self.assertEqual(stream.params["rtmp"], url)
self.assertDictHas(params, stream.params)
def test_plugin(self):
self._test_rtmp("rtmp://hostname.se/stream",
"rtmp://hostname.se/stream", dict())
self._test_rtmp("rtmp://hostname.se/stream live=1 num=47",
"rtmp://hostname.se/stream", dict(live=True, num=47))
self._test_rtmp(
"rtmp://hostname.se/stream live=1 qarg='a \'string' noq=test",
"rtmp://hostname.se/stream",
dict(live=True, qarg='a \'string', noq="test"))
self._test_hls("hls://http://hostname.se/playlist.m3u8",
"http://hostname.se/playlist.m3u8")
self._test_akamaihd("akamaihd://http://hostname.se/stream",
"http://hostname.se", "stream")
class TestPluginStream(unittest.TestCase):
def setUp(self):
self.session = Livestreamer()
def assertDictHas(self, a, b):
for key, value in a.items():
self.assertEqual(b[key], value)
def _test_akamaihd(self, surl, host, streamname):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, AkamaiHDStream))
self.assertEqual(stream.host, host)
self.assertEqual(stream.streamname, streamname)
def _test_hls(self, surl, url):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, HLSStream))
self.assertEqual(stream.url, url)
def _test_rtmp(self, surl, url, params):
channel = self.session.resolve_url(surl)
streams = channel.get_streams()
self.assertTrue("live" in streams)
stream = streams["live"]
self.assertTrue(isinstance(stream, RTMPStream))
self.assertEqual(stream.params["rtmp"], url)
self.assertDictHas(params, stream.params)
def test_plugin(self):
self._test_rtmp("rtmp://hostname.se/stream",
"rtmp://hostname.se/stream", dict())
self._test_rtmp("rtmp://hostname.se/stream live=1 num=47",
"rtmp://hostname.se/stream", dict(live=True, num=47))
self._test_rtmp("rtmp://hostname.se/stream live=1 qarg='a \'string' noq=test",
"rtmp://hostname.se/stream", dict(live=True, qarg='a \'string', noq="test"))
self._test_hls("hls://http://hostname.se/playlist.m3u8",
"http://hostname.se/playlist.m3u8")
self._test_akamaihd("akamaihd://http://hostname.se/stream",
"http://hostname.se", "stream")
def _getLiveUrl(target):
livestreamer = Livestreamer()
streams = livestreamer.streams("http://www.twitch.tv/" + target)
print(streams)
if streams:
# default
# xx = streams.popitem()
# return xx[1].url
xx = streams.get('high')
return xx.url
return None
def _getLiveUrl(target):
livestreamer = Livestreamer()
streams = livestreamer.streams("http://www.twitch.tv/" + target)
print(streams)
if streams:
# default
# xx = streams.popitem()
# return xx[1].url
xx = streams.get('high')
return xx.url
return None
def test_start(model):
model_link_api = 'https://chaturbate.com/api/chatvideocontext/' + model + '/'
result = requests.get(model_link_api).json()
session = Livestreamer()
session.set_option('http-header',"referer=https://www.chaturbate.com/{}/".format(model))
stream = session.streams("hlsvariant://{}".format(result['hls_source'].rsplit('?')[0]))
stream = stream['best']
fd = stream.open()
with open(model + '.mp4', 'wb') as file:
while True:
data = fd.read(1024)
file.write(data)
def __init__(self, threadID, output_location, name, yt_stream, start_time):
threading.Thread.__init__(self)
self.threadID = threadID
self.output = os.path.abspath(output_location)
self.name = name
self.start_time = start_time
self.bufferSize = 1024
self.maxSize = self.bufferSize * 1024 * 50 # 10 MB videos
self.livestreamer = Livestreamer()
self.numOfIndexes = 5
self.outFiles = []
self.yt_stream = yt_stream.strip('\'"')
def startRecording(modelData, num):
try:
recording.append(modelData['username'].lower())
with urllib.request.urlopen(
"https://www.camsoda.com/api/v1/video/vtoken/{model}?username=guest_{num}"
.format(model=modelData['username'], num=num)) as videoapi:
data2 = json.loads(videoapi.read().decode())
if str(modelData['status']) != 'limited':
if str(modelData['status']) == 'private':
server = data2['private_servers'][0]
elif modelData['status'] == 'online':
server = data2['edge_servers'][0]
else:
server = data2['mjpeg_server']
link = "hlsvariant://https://{server}/{app}/mp4:{stream_name}_mjpeg/playlist.m3u8?token={token}".format(
server=server,
app=data2['app'],
stream_name=data2['stream_name'],
token=data2['token'])
if not os.path.exists("{path}/{model}".format(
path=save_directory, model=modelData['username'])):
os.makedirs("{path}/{model}".format(
path=save_directory, model=modelData['username']))
session = Livestreamer()
streams = session.streams(link)
stream = streams["best"]
fd = stream.open()
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime(
"%Y.%m.%d_%H.%M.%S")
with open(
"{path}/{model}/{st}_{model}.mp4".format(
path=save_directory,
model=modelData['username'],
st=st), 'wb') as f:
while True:
try:
data = fd.read(1024)
f.write(data)
except:
recording.remove(modelData['username'].lower())
#print("{} stream has ended".format(modelData['username']))
f.close()
return ()
recording.remove(modelData['username'].lower())
#print("{} stream has ended".format(modelData['username']))
except:
recording.remove(modelData['username'].lower())
def face_detect(x, y, width, height, stream_url):
x = x*426/651
y = y*240/398
width = width*426/651
height = height*240/398
cascade_fn = "haarcascade_frontalface_alt.xml"
nested_fn = "haarcascade_eye.xml"
cascade = cv2.CascadeClassifier(cascade_fn)
nested = cv2.CascadeClassifier(nested_fn)
FFMPEG_BIN = 'C:/ffmpeg/bin/ffmpeg.exe'
livestreamer = Livestreamer()
plugin = livestreamer.resolve_url(stream_url)
streams = plugin.get_streams()
stream = streams.get("best")
VIDEO_URL = stream.url
print VIDEO_URL
pipe = sp.Popen([FFMPEG_BIN, "-i", VIDEO_URL,
"-loglevel", "quiet", # no text output
"-an", # disable audio
"-f", "image2pipe",
"-pix_fmt", "bgr24",
"-vcodec", "rawvideo", "-"],
stdin=sp.PIPE, stdout=sp.PIPE)
interval = 0
while True:
raw_image = pipe.stdout.read(426 * 240 * 3) # read 432*240*3 bytes (= 1 frame)
img = np.fromstring(raw_image, dtype='uint8').reshape((240, 426, 3))
img = img[y:(y + height), x:(x + width)]
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.equalizeHist(gray)
rects = detect(gray, cascade)
vis = img.copy()
if rects:
interval += 1
draw_rects(vis, rects, (0, 255, 0))
for x1, y1, x2, y2 in rects:
roi = gray[y1:y2, x1:x2]
vis_roi = vis[y1:y2, x1:x2]
subrects = detect(roi.copy(), nested)
draw_rects(vis_roi, subrects, (255, 0, 0))
cv2.imwrite('./media/face', vis)
if cv2.waitKey(5) == 27:
break
cv2.destroyAllWindows()
def startRecording(model):
global postProcessingCommand
global processingQueue
try:
result = requests.get('https://chaturbate.com/api/chatvideocontext/{}/'.format(model)).text
result = json.loads(result)
session = Livestreamer()
session.set_option('http-headers', "referer=https://www.chaturbate.com/{}".format(model))
streams = session.streams("hlsvariant://{}".format(result['hls_source'].rsplit('?')[0]))
stream = streams["best"]
fd = stream.open()
now = datetime.datetime.now()
filePath = directory_structure.format(path=save_directory, model=model, gender=result['broadcaster_gender'],
seconds=now.strftime("%S"),
minutes=now.strftime("%M"), hour=now.strftime("%H"),
day=now.strftime("%d"),
month=now.strftime("%m"), year=now.strftime("%Y"))
directory = filePath.rsplit('/', 1)[0]+'/'
if not os.path.exists(directory):
os.makedirs(directory)
with open(filePath, 'wb') as f:
recording.append(model)
while True:
try:
data = fd.read(1024)
f.write(data)
except:
f.close()
recording.remove(model)
if postProcessingCommand != "":
processingQueue.put({'model':model, 'path':filePath, 'gender':gender})
elif completed_directory != "":
finishedDir = completed_directory.format(path=save_directory, model=model,
gender=gender, seconds=now.strftime("%S"),
minutes=now.strftime("%M"),
hour=now.strftime("%H"), day=now.strftime("%d"),
month=now.strftime("%m"), year=now.strftime("%Y"))
if not os.path.exists(finishedDir):
os.makedirs(finishedDir)
os.rename(filePath, finishedDir+'/'+filePath.rsplit['/',1][0])
return
if model in recording:
recording.remove(model)
except:
if model in recording:
recording.remove(model)
def __init__(self, model, save_directory):
self.__model = model
self.save_directory = save_directory
options_url = 'https://it.chaturbate.com/api/chatvideocontext/{}'.format(
model)
self.options = json.loads(requests.get(options_url).content)
self.session = Livestreamer()
self.session.set_option('http-headers',
'referer={}'.format(options_url))
self.streams = None
self.__get_live_streams()
self.__record_status = True
def open(self, url, quality):
"""Attempt to open stream from *url*.
Exits with '-1' (using self.exit()) in case of error, including
an error msg.
"""
self.original_url = url
try:
self.livestreamer = Livestreamer()
self._load_config()
streams = self.livestreamer.streams(url)
except NoPluginError:
self.exit("Livestreamer is unable to handle the URL '{}'".
format(url))
except PluginError as err:
self.exit("Plugin error: {}".format(err))
if quality not in streams:
print("Unable to find '{}' stream on URL '{}'"
.format(quality, url), file=sys.stderr)
self.exit("List of available streams: {}".
format(sorted(streams.keys())))
self.stream = streams[quality]
try:
self.fd = self.stream.open()
except StreamError as err:
self.exit("Failed to open stream: {}".format(err))
def stream_recording():
print("STARTING TO RECORD STREAM")
session = Livestreamer()
stream = session.streams('http://www.twitch.tv/' + channel)
print("CONNECTED TO STREAM")
stream = stream['source']
fd = stream.open()
print("CONNECTED!")
f = open("stream.dat", 'wb')
while True:
data = fd.read(1024)
f.write(data)
def __init__(self):
self.gchoice = -1
self.cchoice = -1
self.exit_now = False
self.state = 'none'
self.keybingings = {
ord('q'): self.quit,
ord('f'): self.get_favorites,
ord('s'): self.get_fav_games,
ord('g'): self.get_games,
ord('n'): self.get_next,
ord('r'): self.refresh,
ord('p'): self.get_previous
}
self.games = []
self.favs = []
self.channels = []
self.twitch = Twitch(config.get('settings', 'twitchapiurl'), config.get('settings', 'channel'), config.get('settings', 'game'))
self.livestreamer = Livestreamer()
try:
self.run()
except Exception as e:
print e.message
def startRecording(model):
try:
model = model.lower()
req = urllib.request.Request('https://www.cam4.com/' + model)
req.add_header('UserAgent', UserAgent)
resp = urllib.request.urlopen(req)
resp = resp.read().decode().splitlines()
videoPlayUrl = ""
videoAppUrl = ""
for line in resp:
if "videoPlayUrl" in line:
for part in line.split("&"):
if "videoPlayUrl" in part and videoPlayUrl == "":
videoPlayUrl = part[13:]
elif "videoAppUrl" in part and videoAppUrl == "":
videoAppUrl = part.split("//")[1]
session = Livestreamer()
session.set_option('http-headers',
"referer=https://www.cam4.com/{}".format(model))
streams = session.streams(
"hlsvariant://https://{}/amlst:{}_aac/playlist.m3u8?referer=www.cam4.com×tamp={}"
.format(videoAppUrl, videoPlayUrl, str(int(time.time() * 1000))))
stream = streams["best"]
fd = stream.open()
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime("%Y.%m.%d_%H.%M.%S")
if not os.path.exists("{path}/{model}".format(path=save_directory,
model=model)):
os.makedirs("{path}/{model}".format(path=save_directory,
model=model))
with open(
"{path}/{model}/{st}_{model}.mp4".format(path=save_directory,
model=model,
st=st), 'wb') as f:
recording.append(model)
while True:
try:
data = fd.read(1024)
f.write(data)
except:
recording.remove(model)
if model in recording:
recording.remove(model)
except:
if model in recording:
recording.remove(model)
def watch(url):
session = Livestreamer()
session.set_loglevel('info')
session.set_logoutput(sys.stdout)
session.set_option('http-headers',
'Client-ID=jzkbprff40iqj646a697cyrvl0zt2m6')
streams = session.streams(url)
stream = streams['audio_only']
fd = stream.open() # read to nowhere
while True:
fd.read(1024)
def main():
session = Livestreamer()
session.set_option("http-headers",
"Client-ID=jzkbprff40iqj646a697cyrvl0zt2m6")
streams = session.streams("twitch.tv/tsm_myth")
stream = streams['720p60']
fname = "downloading.mpg"
vid_file = open(fname, "wb")
fd = stream.open()
new_bytes = 0
for i in range(0, 8 * 1024):
new_bytes = fd.read(2048)
vid_file.write(new_bytes)
print "Done buffering."
startReadingFrames(fname, vid_file, fd)
def startRecording(model):
try:
URL = "https://chaturbate.com/{}/".format(model)
result = urllib.request.urlopen(URL)
result = result.read().decode()
for line in result.splitlines():
if "m3u8" in line:
stream = line.split("'")[1]
break
soup = BeautifulSoup(result, 'lxml')
soup = soup.findAll('div', id="tabs_content_container")
for line in str(soup).split():
if 'Sex:' in line:
gender = line.split("</dt><dd>")[1][:-5].lower()
session = Livestreamer()
session.set_option('http-headers',
"referer=https://www.cam4.com/{}".format(model))
streams = session.streams("hlsvariant://{}".format(stream))
stream = streams["best"]
fd = stream.open()
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime("%d.%m.%Y_%H.%M.%S")
if not os.path.exists("{path}/{model}_{gender}".format(
path=save_directory, model=model, gender=gender)):
os.makedirs("{path}/{model}_{gender}".format(path=save_directory,
model=model,
gender=gender))
with open(
"{path}/{model}_{gender}/{st}_{model}_{gender}.mp4".format(
path=save_directory, model=model, gender=gender, st=st),
'wb') as f:
recording.append(model)
while True:
try:
data = fd.read(1024)
f.write(data)
except:
f.close()
recording.remove(model)
return
if model in recording:
recording.remove(model)
except:
if model in recording:
recording.remove(model)
class recordingThread(threading.Thread):
def __init__(self, threadID, output_location, name, yt_stream, start_time):
threading.Thread.__init__(self)
self.threadID = threadID
self.output = os.path.abspath(output_location)
self.name = name
self.start_time = start_time
self.bufferSize = 1024
self.maxSize = self.bufferSize * 1024 * 50 # 10 MB videos
self.livestreamer = Livestreamer()
self.numOfIndexes = 5
self.outFiles = []
self.yt_stream = yt_stream.strip('\'"')
def run(self):
print "Starting %s Thread Recorder - %s" % (self.name, self.start_time)
name_conv_dict = {
'output_location': self.output,
'name': self.name,
'time': time.strftime("%H%M_%d%b%y")
}
output_location = NAME_FORMAT.format(**name_conv_dict)
try:
available_streams = self.livestreamer.streams(self.yt_stream)
bestStream = available_streams['best']
stream_obj = bestStream.open()
for i in range(self.numOfIndexes):
outFileName = output_location.replace(".mp4",
"_" + str(i) + ".mp4")
self.outFiles.append(outFileName)
outVid = open(outFileName, 'ab')
currByteCount = 0
while currByteCount < self.maxSize:
data = stream_obj.read(512 * 1024)
outVid.write(data)
currByteCount += 512 * 1024
outVid.flush()
stream_obj.close()
except LivestreamerError as err:
print self.threadID + " Exception."
print err
except Exception, e:
print self.threadID + " Exception."
print e.message
print self.name + " Done Recording."
outVid.close()
print self.name + " Re-encoding..."
self.reencode()
print self.name + " Re-encoding Done."
def start(portNum):
global LIVESTREAMER
LIVESTREAMER = Livestreamer()
LIVESTREAMER.set_option('hls-segment-threads', '3')
LIVESTREAMER.set_option('hds-segment-threads', '3')
LIVESTREAMER.set_option('stream-segment-threads', '3')
global httpd
#httpd = ThreadedHTTPServer(('', portNum), StreamHandler)
httpd = StoppableHTTPServer(('', portNum), StreamHandler)
try:
#thread.start_new_thread(httpd.serve, ())
t1 = threading.Thread(target = httpd.serve, args = ())
t1.daemon = True
t1.start()
print "Livestreamer: Server Starts - {0}:{1}".format("localhost", portNum)
except Exception as ex:
print ex
def serveFile(self, fURL, sendData):
from livestreamer import Livestreamer, StreamError, PluginError, NoPluginError
session = Livestreamer()
if '|' in fURL:
sp = fURL.split('|')
fURL = sp[0]
headers = dict(urlparse.parse_qsl(sp[1]))
session.set_option("http-headers", headers)
session.set_option("http-ssl-verify",False)
try:
streams = session.streams(fURL)
except:
traceback.print_exc(file=sys.stdout)
self.send_response(403)
self.send_response(200)
#print "XBMCLocalProxy: Sending headers..."
self.end_headers()
if (sendData):
#print "XBMCLocalProxy: Sending data..."
fileout = self.wfile
try:
stream = streams["best"]
try:
response = stream.open()
buf = 'INIT'
while (buf != None and len(buf) > 0):
buf = response.read(300 * 1024)
fileout.write(buf)
fileout.flush()
response.close()
fileout.close()
#print time.asctime(), "Closing connection"
except socket.error, e:
#print time.asctime(), "Client Closed the connection."
try:
response.close()
fileout.close()
except Exception, e:
return
except Exception, e:
traceback.print_exc(file=sys.stdout)
response.close()
fileout.close()
def get_stream(stream_url):
# change to a stream that is actually online
livestreamer = Livestreamer()
stream = None
try:
plugin = livestreamer.resolve_url("http://www.twitch.tv/" + stream_url)
plugin.set_option('oauth_token', 'xtlhyl6uapy6znsvuhy4zfk0jbt086')
streams = plugin.get_streams()
# It seems best isn't necessarily the best, twitch doesn't seem to consider 60
# streams, so we should search for those first.
if '1080p60' in streams:
stream = streams['1080p60']
elif '720p60' in streams:
stream = streams['720p60']
else:
stream = streams['best']
except Exception:
pass
return stream
def start(portNum):
global LIVESTREAMER
LIVESTREAMER = Livestreamer()
global httpd
httpd = ThreadedHTTPServer(("localhost", portNum), StreamHandler)
print "Livestreamer: Server Starts - {0}:{1}".format("localhost", portNum)
try:
httpd.serve_forever()
except:
pass
def serveFile(self, fURL, sendData):
from livestreamer import Livestreamer, StreamError, PluginError, NoPluginError
session = Livestreamer()
if '|' in fURL:
sp = fURL.split('|')
fURL = sp[0]
headers = dict(urlparse.parse_qsl(sp[1]))
session.set_option("http-headers", headers)
try:
streams = session.streams(fURL)
except:
traceback.print_exc(file=sys.stdout)
self.send_response(403)
self.send_response(200)
#print "XBMCLocalProxy: Sending headers..."
self.end_headers()
if (sendData):
#print "XBMCLocalProxy: Sending data..."
fileout = self.wfile
try:
stream = streams["best"]
try:
response = stream.open()
buf = 'INIT'
while (buf != None and len(buf) > 0):
buf = response.read(300 * 1024)
fileout.write(buf)
fileout.flush()
response.close()
fileout.close()
#print time.asctime(), "Closing connection"
except socket.error, e:
#print time.asctime(), "Client Closed the connection."
try:
response.close()
fileout.close()
except Exception, e:
return
except Exception, e:
traceback.print_exc(file=sys.stdout)
response.close()
fileout.close()
def serveFile(self, fURL, sendData):
if (sendData):
fURL, quality = player.GetStreamUrl(unquote(fURL))
session = Livestreamer()
if '|' in fURL:
sp = fURL.split('|')
fURL = sp[0]
headers = dict(urlparse.parse_qsl(sp[1]))
session.set_option("http-headers", headers)
session.set_option("http-ssl-verify", False)
session.set_option("hls-segment-threads", 3)
session.set_option("stream-segment-threads", 3)
try:
#streams = session.streams(fURL)
channel = session.resolve_url(fURL)
streams = channel.get_streams()
except Exception as ex:
traceback.print_exc(file=sys.stdout)
self.send_response(403)
self.send_response(200)
#print "XBMCLocalProxy: Sending headers..."
self.end_headers()
#print "XBMCLocalProxy: Sending data..."
fileout = self.wfile
try:
stream = streams[quality]
try:
response = stream.open()
buf = 'INIT'
while (buf != None and len(buf) > 0):
buf = response.read(200 * 1024)
fileout.write(buf)
fileout.flush()
response.close()
fileout.close()
#print time.asctime(), "Closing connection"
except socket.error, e:
#print time.asctime(), "Client Closed the connection."
try:
response.close()
fileout.close()
except Exception, e:
return
except Exception, e:
traceback.print_exc(file=sys.stdout)
response.close()
fileout.close()
def _init_stream(self, oauth, channel):
session = Livestreamer()
session.set_plugin_option(self.LIVESTREAMER_PLUGIN_TWITCH,
self.OAUTH_TOKEN_KEY, oauth)
session.set_option(self.RING_BUFFER_SIZE_KEY, self.buffer_size)
streams = session.streams(self._generate_stream_url(channel))
return streams.get(self.resolution)
def startRecording(model):
try:
recording[model['uid']] = model['nm']
session = Livestreamer()
streams = session.streams("hlsvariant://http://video{srv}.myfreecams.com:1935/NxServer/ngrp:mfc_{id}.f4v_mobile/playlist.m3u8"
.format(id=(int(model['uid']) + 100000000),
srv=(int(model['camserv']) - 500)))
stream = streams["best"]
fd = stream.open()
now = datetime.datetime.now()
filePath = directory_structure.format(path=save_directory, model=model['nm'], uid=model['uid'],
seconds=now.strftime("%S"), day=now.strftime("%d"),
minutes=now.strftime("%M"), hour=now.strftime("%H"),
month=now.strftime("%m"), year=now.strftime("%Y"))
directory = filePath.rsplit('/', 1)[0]+'/'
if not os.path.exists(directory):
os.makedirs(directory)
with open(filePath, 'wb') as f:
minViewers = filter['autoStopViewers'] if model['condition'] == 'viewers' else filter['stopViewers']
while modelDict[model['uid']]['rc'] >= minViewers:
try:
data = fd.read(1024)
f.write(data)
except:
f.close()
recording.pop(model['uid'], None)
recording.pop(model['uid'], None)
if postProcessingCommand != "":
processingQueue.put({'model':model['nm'], 'path': filePath, 'uid':model['uid']})
elif completed_directory != "":
finishedDir = completed_directory.format(path=save_directory, model=model, uid=model['uid'],
seconds=now.strftime("%S"), minutes=now.strftime("%M"),
hour=now.strftime("%H"), day=now.strftime("%d"),
month=now.strftime("%m"), year=now.strftime("%Y"))
if not os.path.exists(finishedDir):
os.makedirs(finishedDir)
os.rename(filePath, finishedDir+'/'+filePath.rsplit('/', 1)[1])
return
finally:
recording.pop(model['uid'], None)
def __init__(self, session, streamFile=None):
self.session = session
Screen.__init__(self, session)
self['info'] = Label('...')
self['actions'] = ActionMap(
[
'OkCancelActions', 'ShortcutActions', 'WizardActions',
'ColorActions', 'SetupActions', 'NumberActions', 'MenuActions'
], {
'ok': self.keyOK,
'cancel': self.keyCancel,
'up': self.keyUp,
'down': self.keyDown,
'left': self.keyLeft,
'right': self.keyRight
}, -1)
self.streamBin = '/usr/bin/rtmpdump'
self.streamPipe = '/tmp/greekstreamtv.avi'
if not streamFile:
self.streamFile = resolveFilename(
SCOPE_PLUGINS, 'Extensions/GreekStreamTV/stream.xml')
else:
self.streamFile = streamFile
self.lvstreamer = Livestreamer()
self.streamList = []
self.makeStreamList()
self.streamMenuList = MenuList([],
enableWrapAround=True,
content=eListboxPythonMultiContent)
self.streamMenuList.l.setFont(0, gFont('Regular', 22))
self.streamMenuList.l.setFont(1, gFont('Regular', 18))
self.streamMenuList.l.setItemHeight(37)
self['streamlist'] = self.streamMenuList
self.streamMenuList.setList(map(streamListEntry, self.streamList))
self.onLayoutFinish.append(self.layoutFinished)
self.beforeService = None
self.currentService = None
self.playerStoped = False
self.keyLocked = False
self.pd = None
self.qsel = None
return
def stream_recording():
from livestreamer import Livestreamer
print(": Starting to record stream")
session = Livestreamer()
stream = session.streams('http://www.twitch.tv/' + channel)
print("Connecting to stream")
stream = stream['source']
fd = stream.open()
print("Connected!")
#lock = threading.Lock()
f = open("stream.dat", 'wb')# with open("stream.dat", 'wb') as f:
global front
while True:
data = fd.read(1024)
f.write(data)
front += len(data)
def startRecording(model):
try:
URL = "https://chaturbate.com/{}/".format(model)
result = urllib.request.urlopen(URL)
result = result.read().decode()
for line in result.splitlines():
if "m3u8" in line:
stream = line.split("'")[1]
break
session = Livestreamer()
session.set_option(
'http-headers',
"referer=https://www.chaturbate.com/{}".format(model))
streams = session.streams("hlsvariant://{}".format(stream))
stream = streams["best"]
fd = stream.open()
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime("%Y.%m.%d_%H.%M.%S")
if not os.path.exists("{path}/{model}".format(path=save_directory,
model=model)):
os.makedirs("{path}/{model}".format(path=save_directory,
model=model))
with open(
"{path}/{model}/{st}_{model}.mp4".format(path=save_directory,
model=model,
st=st), 'wb') as f:
recording.append(model)
while True:
try:
data = fd.read(1024)
f.write(data)
except:
f.close()
recording.remove(model)
return
if model in recording:
recording.remove(model)
except:
if model in recording:
recording.remove(model)
def __init__(self, session, streamFile=None):
Screen.__init__(self, session)
self.setTitle(_("GreekStreamTV list"))
self["info"] = Label("...")
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Play"))
self["actions"] = ActionMap(["OkCancelActions", "WizardActions", "ColorActions"],
{
"ok" : self.keyOK,
"green" : self.keyOK,
"cancel": self.keyCancel,
"red" : self.keyCancel,
"up" : self.keyUp,
"down" : self.keyDown,
"left" : self.keyLeft,
"right" : self.keyRight,
}, -1)
self.streamBin = "/usr/bin/rtmpdump"
self.streamPipe = "/tmp/greekstreamtv.avi"
if not streamFile:
self.streamFile = resolveFilename(SCOPE_PLUGINS, "Extensions/GreekStreamTV/stream.xml")
else:
self.streamFile = streamFile
self.lvstreamer = Livestreamer()
self.streamList = []
self.makeStreamList()
self["streamlist"] = StreamList(self.streamList)
self.onLayoutFinish.append(self.layoutFinished)
self.beforeService = None
self.currentService = None
self.playerStoped = False
self.keyLocked = False
self.pd = None
self.qsel = None
def openStream(url, quality):
"""Open a livestreamer URL and return the stream"""
livestreamer = Livestreamer()
setOptions(livestreamer)
try:
streams = livestreamer.streams(url)
except NoPluginError:
print("Unable to Find Plugin")
abort(404)
except PluginError as err:
print("Plugin error: {0}".format(err))
abort(404)
if quality not in streams:
print("Quality {0} not available in {1}".format(quality, url))
abort(404)
return streams[quality]
def openStream(url, quality):
"""Open a livestreamer URL and return the stream"""
livestreamer = Livestreamer()
setOptions(livestreamer)
try:
streams = livestreamer.streams(url)
except NoPluginError:
print("Unable to Find Plugin")
abort(404)
except PluginError as err:
print("Plugin error: {0}".format(err))
abort(404)
if quality not in streams:
print("Quality {0} not available in {1}".format(quality, url))
abort(404)
return streams[quality]
class Application:
def __init__(self, window, stream_list):
self.window = window
self.stream_list = stream_list
self.livestreamer = Livestreamer()
def refresh_key(self):
self.stream_list.update_streamers()
self.refresh_screen()
def refresh_screen(self):
self.window.screen.erase()
self.window.draw_borders()
self.window.draw_help()
self.stream_list.draw_streamers()
self.window.screen.refresh()
def up_key(self, distance=1):
self.stream_list.move_up(distance)
self.refresh_screen()
def down_key(self, distance=1):
self.stream_list.move_down(distance)
self.refresh_screen()
def sort_key(self):
self.stream_list.toggle_sort()
self.refresh_screen()
def sort_order_key(self):
self.stream_list.toggle_sort_order()
self.refresh_screen()
def resize_event(self):
self.window.resize_term()
self.refresh_screen()
def play_stream(self, livestreamer_config=None, quality="best"):
url = self.stream_list.get_twitch_url()
streams = self.livestreamer.streams(url)
stream = streams[quality]
call = []
call.append('livestreamer')
call.append('--quiet')
if livestreamer_config is not None:
call.append('--config')
call.append(livestreamer_config)
call.append(url)
call.append(quality)
subprocess.Popen(call)
def main():
if len(sys.argv) < 3:
exit("Usage: {0} <url> <quality>".format(sys.argv[0]))
gi.require_version("Gst", "1.0")
gobject.threads_init()
gst.init(None)
url = sys.argv[1]
quality = sys.argv[2]
livestreamer = Livestreamer()
livestreamer.set_loglevel("info")
livestreamer.set_logoutput(sys.stdout)
try:
streams = livestreamer.streams(url)
except NoPluginError:
exit("Livestreamer is unable to handle the URL '{0}'".format(url))
except PluginError as err:
exit("Plugin error: {0}.".format(err))
if not streams:
exit("No streams found on URL '{0}'.".format(url))
if quality not in streams:
exit("Unable to find '{0}' stream on URL '{1}'".format(quality, url))
stream = streams[quality]
player = LivestreamerPlayer()
player.play(stream)
def __init__(self, filename, rc_module):
""" Init and try to load a stream list, nothing about curses yet """
self.db_was_read = False
# Open the storage (create it if necessary
try:
f = shelve.open(filename, 'c')
except Exception:
raise ShelveError(
'Database could not be opened, another livestreamer-curses instance might be already running. '
'Please note that a database created with Python 2.x cannot be used with Python 3.x and vice versa.'
)
self.max_id = 0
# Sort streams by view count
try:
self.streams = sorted(f['streams'], key=lambda s:s['seen'], reverse=True)
for s in self.streams:
# Max id, needed when adding a new stream
self.max_id = max(self.max_id, s['id'])
s['online'] = 2
except:
self.streams = []
self.db_was_read = True
self.filtered_streams = list(self.streams)
self.filter = ''
self.all_streams_offline = None
self.show_offline_streams = False
self.rc_module = rc_module
if 'LIVESTREAMER_COMMANDS' in dir(self.rc_module):
self.cmd_list = list(map(shlex.split, self.rc_module.LIVESTREAMER_COMMANDS))
else:
self.cmd_list = [['livestreamer']]
self.cmd_index = 0
self.cmd = self.cmd_list[self.cmd_index]
if 'DEFAULT_RESOLUTION' in dir(self.rc_module):
self.default_res = self.rc_module.DEFAULT_RESOLUTION
else:
self.default_res = DEFAULT_RESOLUTION_HARD
self.store = f
self.store.sync()
self.no_streams = self.streams == []
self.no_stream_shown = self.no_streams
self.q = ProcessList(StreamPlayer().play)
self.livestreamer = Livestreamer()
def serveFile(self, fURL, sendData):
if (sendData):
fURL, quality = player.GetStreamUrl(unquote(fURL))
session = Livestreamer()
if '|' in fURL:
sp = fURL.split('|')
fURL = sp[0]
headers = dict(urlparse.parse_qsl(sp[1]))
session.set_option("http-headers", headers)
session.set_option("http-ssl-verify",False)
session.set_option("hls-segment-threads",3)
session.set_option("stream-segment-threads",3)
try:
#streams = session.streams(fURL)
channel = session.resolve_url(fURL)
streams = channel.get_streams()
except Exception as ex:
traceback.print_exc(file=sys.stdout)
self.send_response(403)
self.send_response(200)
#print "XBMCLocalProxy: Sending headers..."
self.end_headers()
#print "XBMCLocalProxy: Sending data..."
fileout = self.wfile
try:
stream = streams[quality]
try:
response = stream.open()
buf = 'INIT'
while (buf != None and len(buf) > 0):
buf = response.read(200 * 1024)
fileout.write(buf)
fileout.flush()
response.close()
fileout.close()
#print time.asctime(), "Closing connection"
except socket.error, e:
#print time.asctime(), "Client Closed the connection."
try:
response.close()
fileout.close()
except Exception, e:
return
except Exception, e:
traceback.print_exc(file=sys.stdout)
response.close()
fileout.close()
def __init__(self, master):
self.master = master
self.frame = tk.Frame(self.master)
gobject.threads_init()
gst.init(None)
self.livestreamer = Livestreamer()
self.livestreamer.set_loglevel("info")
self.livestreamer.set_logoutput(sys.stdout)
self.fd = None
try:
self.streams = self.livestreamer.streams('http://www.twitch.tv/saltybet')
except NoPluginError:
exit("Livestreamer failed to handle the url.")
except PluginError as err:
exit("Livestreamer plugin error: {}".format(err))
if not self.streams:
exit("No streams found.")
if 'best' not in self.streams:
exit("Unable to select livestreamer quality.")
self.stream = self.streams['best']
try:
self.fd = self.stream.open()
except SteamError as err:
self.exit("Livestreamer failed to open stream.")
self.init_gui()
# self.login()
self.window_id = self.video.winfo_id()
self.player = gst.ElementFactory.make('playbin', None)
self.player.set_property('video-sink', None)
self.player.set_property('uri', 'appsrc://')
self.player.connect('source-setup', self.on_source_setup)
self.bus = self.player.get_bus()
self.bus.add_signal_watch()
self.bus.enable_sync_message_emission()
self.bus.connect('sync-message::element', self.on_sync_message, self.window_id)
self.bus.connect('message::eos', self.on_eos)
self.bus.connect('message::error', self.on_error)
self.player.set_state(gst.State.PLAYING)
def startRecording(model):
try:
model = model.lower()
resp = requests.get('https://www.cam4.com/' + model, headers={'user-agent':'UserAgent'}).text.splitlines()
videoPlayUrl = ""
videoAppUrl = ""
for line in resp:
if "videoPlayUrl" in line:
for part in line.split("&"):
if "videoPlayUrl" in part and videoPlayUrl == "":
videoPlayUrl = part[13:]
elif "videoAppUrl" in part and videoAppUrl == "":
videoAppUrl = part.split("//")[1]
session = Livestreamer()
session.set_option('http-headers', "referer=https://www.cam4.com/{}".format(model))
streams = session.streams("hlsvariant://https://{}/amlst:{}_aac/playlist.m3u8?referer=www.cam4.com×tamp={}"
.format(videoAppUrl, videoPlayUrl, str(int(time.time() * 1000))))
stream = streams["best"]
fd = stream.open()
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime("%Y.%m.%d_%H.%M.%S")
file = os.path.join(setting['save_directory'], model, "{st}_{model}.mp4".format(path=setting['save_directory'], model=model,
st=st))
os.makedirs(os.path.join(setting['save_directory'], model), exist_ok=True)
with open(file, 'wb') as f:
recording.append(model)
while True:
try:
data = fd.read(1024)
f.write(data)
except:
break
if setting['postProcessingCommand']:
processingQueue.put({'model': model, 'path': file})
finally:
if model in recording:
recording.remove(model)
def run(self):
print('Starting ' + self.username)
session = Livestreamer()
session.set_option('http-headers',
'Client-ID=jzkbprff40iqj646a697cyrvl0zt2m6')
streams = session.streams("http://twitch.tv/" + self.username)
assert len(streams) != 0, 'Stream not open.'
directory = os.path.join('images', self.username)
try:
os.makedirs(directory)
except:
pass
qualities = streams.keys()
stream = None
if '360p' in qualities:
stream = streams['360p']
# elif 'medium' in qualities:
# stream = streams['medium']
assert stream is not None, self.username + ': No valid stream quality found.'
period = 10
timer = time.time() + period
data = b''
with stream.open() as fd:
while True:
data += fd.read(self.buf_160)
if time.time() > timer:
timer = time.time() + period
ts = str(int(time.time()))
fname = self.username + '_' + ts
path = os.path.join('movies', fname + '.mp4')
print(path)
open(path, 'wb').write(data)
data = b''
def serveFile(self, fURL, sendData):
from livestreamer import Livestreamer, StreamError, PluginError, NoPluginError
session = Livestreamer()
if '|' in fURL:
sp = fURL.split('|')
fURL = sp[0]
headers = dict(urlparse.parse_qsl(sp[1]))
session.set_option("http-headers", headers)
cookies = dict(urlparse.parse_qsl(sp[2]))
session.set_option("http-cookie", cookies)
streams = session.streams(fURL)
except:
def __init__(self):
# Init stuff
gi.require_version("Gst", "1.0")
glib.threads_init()
gobject.threads_init()
gst.init(None)
# Vars
self.is_running = True
self.current_id = -1
self.current_url = ""
self.current_stream = None
self.session = Livestreamer()
self.player = None
self.window = None
def serveFile(self, fURL, sendData):
session = Livestreamer()
if '|' in fURL:
sp = fURL.split('|')
fURL = sp[0]
headers = dict(urlparse.parse_qsl(sp[1]))
if 'cdn.sstream.pw' in fURL:
fURL = fURL.replace('cdn.sstream.pw',random.choice(s))
headers['Host'] = '6b6473616a6b6c647361646a7361643737353637647361393973616768647368686464732e736974656e6f772e6d65'.decode('hex')
session.set_option("http-headers", headers)
session.set_option("http-ssl-verify",False)
session.set_option("hls-segment-threads",3)
try:
streams = session.streams(fURL)
except:
traceback.print_exc(file=sys.stdout)
self.send_response(403)
self.send_response(200)
#print "XBMCLocalProxy: Sending headers..."
self.end_headers()
if (sendData):
#print "XBMCLocalProxy: Sending data..."
fileout = self.wfile
try:
stream = streams["best"]
try:
response = stream.open()
buf = 'INIT'
while (buf != None and len(buf) > 0):
buf = response.read(200 * 1024)
fileout.write(buf)
fileout.flush()
response.close()
fileout.close()
#print time.asctime(), "Closing connection"
except socket.error, e:
#print time.asctime(), "Client Closed the connection."
try:
response.close()
fileout.close()
except Exception, e:
return
except Exception, e:
traceback.print_exc(file=sys.stdout)
response.close()
fileout.close()
def __init__(self, session, streamFile = None):
self.session = session
Screen.__init__(self, session)
self['info'] = Label('...')
self['actions'] = ActionMap(['OkCancelActions',
'ShortcutActions',
'WizardActions',
'ColorActions',
'SetupActions',
'NumberActions',
'MenuActions'], {'ok': self.keyOK,
'cancel': self.keyCancel,
'up': self.keyUp,
'down': self.keyDown,
'left': self.keyLeft,
'right': self.keyRight}, -1)
self.streamBin = '/usr/bin/rtmpdump'
self.streamPipe = '/tmp/greekstreamtv.avi'
if not streamFile:
self.streamFile = resolveFilename(SCOPE_PLUGINS, 'Extensions/GreekStreamTV/stream.xml')
else:
self.streamFile = streamFile
self.lvstreamer = Livestreamer()
self.streamList = []
self.makeStreamList()
self.streamMenuList = MenuList([], enableWrapAround=True, content=eListboxPythonMultiContent)
self.streamMenuList.l.setFont(0, gFont('Regular', 22))
self.streamMenuList.l.setFont(1, gFont('Regular', 18))
self.streamMenuList.l.setItemHeight(37)
self['streamlist'] = self.streamMenuList
self.streamMenuList.setList(map(streamListEntry, self.streamList))
self.onLayoutFinish.append(self.layoutFinished)
self.beforeService = None
self.currentService = None
self.playerStoped = False
self.keyLocked = False
self.pd = None
self.qsel = None
return
def init_gstream(self):
# if len(sys.argv) < 3:
# exit("Usage: {0} <url> <quality>".format(sys.argv[0]))
# Initialize and check GStreamer version
gi.require_version("Gst", "1.0")
gobject.threads_init()
gst.init(None)
# Collect arguments
url = "twitch.tv/" + self.stream_textbox.get_text()
# Create the Livestreamer session
livestreamer = Livestreamer()
# Enable logging
livestreamer.set_loglevel("info")
livestreamer.set_logoutput(sys.stdout)
# Attempt to fetch streams
try:
streams = livestreamer.streams(url)
except NoPluginError:
print("Livestreamer is unable to handle the URL '{0}'".format(url))
except PluginError as err:
print("Plugin error: {0}".format(err))
if not streams:
print("No streams found on URL '{0}'".format(url))
# Look for specified stream
elif self.quality not in streams:
print("Unable to find '{0}' stream on URL '{1}'".format(self.quality, url))
# We found the stream
else:
stream = streams[self.quality]
# Create the player and start playback
# player = LivestreamerPlayer()
win = PI()
win.play(stream)
win.connect("delete-event", gtk.main_quit)
win.show_all()
win.main()
def get_streams(self):
live = Livestreamer()
print self.url
live.set_option("http-ssl-verify", False)
streams = None
live.load_plugins(os.path.join(os.getcwd(), "plugins"))
try:
plugin = live.resolve_url(self.url)
streams = plugin.get_streams()
self.play_url = stream_to_url(streams.get("best"))
except NoPluginError:
print("No plugin can handle URL")
except PluginError as err:
print("{0}", err)
def main():
if len(sys.argv) < 3:
exit("Usage: {0} <url> <quality>".format(sys.argv[0]))
# Initialize and check GStreamer version
gi.require_version("Gst", "1.0")
gobject.threads_init()
gst.init(None)
# Collect arguments
url = sys.argv[1]
quality = sys.argv[2]
# Create the Livestreamer session
livestreamer = Livestreamer()
# Enable logging
livestreamer.set_loglevel("info")
livestreamer.set_logoutput(sys.stdout)
# Attempt to fetch streams
try:
streams = livestreamer.streams(url)
except NoPluginError:
exit("Livestreamer is unable to handle the URL '{0}'".format(url))
except PluginError as err:
exit("Plugin error: {0}".format(err))
if not streams:
exit("No streams found on URL '{0}'".format(url))
# Look for specified stream
if quality not in streams:
exit("Unable to find '{0}' stream on URL '{1}'".format(quality, url))
# We found the stream
stream = streams[quality]
# Create the player and start playback
player = LivestreamerPlayer()
# Blocks until playback is done
player.play(stream)
def main():
if len(sys.argv) < 3:
exit("Usage: {0} <url> <quality>".format(sys.argv[0]))
# Collect arguments
url = sys.argv[1]
quality = sys.argv[2]
# Create the Livestreamer session
livestreamer = Livestreamer()
# Enable logging
livestreamer.set_loglevel("info")
livestreamer.set_logoutput(sys.stdout)
# Attempt to find a plugin for this URL
try:
plugin = livestreamer.resolve_url(url)
except NoPluginError:
exit("Livestreamer is unable to handle the URL '{0}'".format(url))
# Attempt to fetch streams
try:
streams = plugin.get_streams()
except PluginError as err:
exit("Plugin error: {0}".format(err))
if len(streams) == 0:
exit("No streams found on URL '{0}'".format(url))
# Look for specified stream
if quality not in streams:
exit("Unable to find '{0}' stream on URL '{1}'".format(quality, url))
# We found the stream
stream = streams[quality]
# Create the player and start playback
player = LivestreamerPlayer()
# Blocks until playback is done
player.play(stream)
def serveFile(self, fURL, sendData):
session = Livestreamer()
if '|' in fURL:
sp = fURL.split('|')
fURL = sp[0]
headers = dict(urlparse.parse_qsl(sp[1]))
session.set_option("http-headers", headers)
session.set_option("http-ssl-verify", False)
try:
streams = session.streams(fURL)
self.send_response(200)
except:
self.send_response(403)
finally:
self.end_headers()
if (sendData):
with streams["best"].open() as stream:
buf = 'INIT'
while (len(buf) > 0):
buf = stream.read(500 * 1024)
self.wfile.write(buf)
def check_online(stream_name):
# Collect arguments
url = "twitch.tv/" + stream_name
# Create the Livestreamer session
livestreamer = Livestreamer()
# Enable logging
livestreamer.set_loglevel("info")
livestreamer.set_logoutput(sys.stdout)
# Attempt to fetch streams
try:
streams = livestreamer.streams(url)
except NoPluginError:
print("Livestreamer is unable to handle the URL '{0}'".format(url))
except PluginError as err:
print("Plugin error: {0}".format(err))
if not streams:
print("No streams found on URL '{0}'".format(url))
return False
else:
return True
import av
import time
from livestreamer import Livestreamer
while True:
session = Livestreamer()
streams = session.streams('http://www.twitch.tv/Livibee')
stream = streams['source']
container = av.open(stream.url)
video_stream = next(s for s in container.streams if s.type == b'video')
image = None
for packet in container.demux(video_stream):
for frame in packet.decode():
image = frame.to_image()
timestr = time.strftime("%Y%m%d-%H%M%S")
image.save("stream_grabs/%s.png" % timestr)
if image:
break
if image:
break
time.sleep(1)
def setUp(self):
self.session = Livestreamer()
class TestSession(unittest.TestCase):
PluginPath = os.path.join(os.path.dirname(__file__), "plugins")
def setUp(self):
self.session = Livestreamer()
self.session.load_plugins(self.PluginPath)
def test_exceptions(self):
try:
self.session.resolve_url("invalid url")
self.assertTrue(False)
except NoPluginError:
self.assertTrue(True)
def test_load_plugins(self):
plugins = self.session.get_plugins()
self.assertTrue(plugins["testplugin"])
def test_builtin_plugins(self):
plugins = self.session.get_plugins()
self.assertTrue("justintv" in plugins)
def test_resolve_url(self):
plugins = self.session.get_plugins()
channel = self.session.resolve_url("http://test.se/channel")
self.assertTrue(isinstance(channel, Plugin))
self.assertTrue(isinstance(channel, plugins["testplugin"]))
def test_options(self):
self.session.set_option("test_option", "option")
self.assertEqual(self.session.get_option("test_option"), "option")
self.assertEqual(self.session.get_option("non_existing"), None)
self.assertEqual(self.session.get_plugin_option("testplugin", "a_option"), "default")
self.session.set_plugin_option("testplugin", "another_option", "test")
self.assertEqual(self.session.get_plugin_option("testplugin", "another_option"), "test")
self.assertEqual(self.session.get_plugin_option("non_existing", "non_existing"), None)
self.assertEqual(self.session.get_plugin_option("testplugin", "non_existing"), None)
def test_plugin(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams()
self.assertTrue("best" in streams)
self.assertTrue("worst" in streams)
self.assertTrue(streams["best"] is streams["1080p"])
self.assertTrue(streams["worst"] is streams["350k"])
self.assertTrue(isinstance(streams["rtmp"], RTMPStream))
self.assertTrue(isinstance(streams["http"], HTTPStream))
self.assertTrue(isinstance(streams["hls"], HLSStream))
self.assertTrue(isinstance(streams["akamaihd"], AkamaiHDStream))
def test_plugin_stream_types(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams(stream_types=["http", "rtmp"])
self.assertTrue(isinstance(streams["480p"], HTTPStream))
self.assertTrue(isinstance(streams["480p_rtmp"], RTMPStream))
streams = channel.get_streams(stream_types=["rtmp", "http"])
self.assertTrue(isinstance(streams["480p"], RTMPStream))
self.assertTrue(isinstance(streams["480p_http"], HTTPStream))
def test_plugin_stream_sorted_excludes(self):
channel = self.session.resolve_url("http://test.se/channel")
streams = channel.get_streams(sorting_excludes=["1080p", "3000k"])
self.assertTrue("best" in streams)
self.assertTrue("worst" in streams)
self.assertTrue(streams["best"] is streams["1500k"])