1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
from livestreamer.compat import str
from livestreamer.options import Options
from livestreamer.plugins import Plugin, PluginError, NoStreamsError
from livestreamer.stream import RTMPStream
from livestreamer.utils import swfverify, urlget
import re
import random
import xml.dom.minidom
class JustinTV(Plugin):
options = Options({
"cookie": None
})
StreamInfoURL = "http://usher.justin.tv/find/{0}.xml"
MetadataURL = "http://www.justin.tv/meta/{0}.xml?on_site=true"
SWFURL = "http://www.justin.tv/widgets/live_embed_player.swf"
@classmethod
def can_handle_url(self, url):
return ("justin.tv" in url) or ("twitch.tv" in url)
def _get_channel_name(self, url):
return url.rstrip("/").rpartition("/")[2].lower()
def _get_metadata(self):
url = self.MetadataURL.format(self.channelname)
headers = {}
cookie = self.options.get("cookie")
if cookie:
headers["Cookie"] = cookie
res = urlget(url, headers=headers)
try:
dom = xml.dom.minidom.parseString(res.text)
except Exception as err:
raise PluginError(("Unable to parse config XML: {0})").format(err))
meta = dom.getElementsByTagName("meta")[0]
metadata = {}
metadata["title"] = self._get_node_if_exists(dom, "title")
metadata["access_guid"] = self._get_node_if_exists(dom, "access_guid")
metadata["login"] = self._get_node_if_exists(dom, "login")
return metadata
def _get_node_if_exists(self, dom, name):
elements = dom.getElementsByTagName(name)
if elements and len(elements) > 0:
return self._get_node_text(elements[0])
def _get_node_text(self, element):
res = []
for node in element.childNodes:
if node.nodeType == node.TEXT_NODE:
res.append(node.data)
if len(res) == 0:
return None
else:
return "".join(res)
def _authenticate(self):
chansub = None
if self.options.get("cookie") is not None:
self.logger.info("Attempting to authenticate using cookies")
metadata = self._get_metadata()
chansub = metadata["access_guid"]
if "login" in metadata and metadata["login"] is not None:
self.logger.info("Successfully logged in as {0}", metadata["login"])
return chansub
def _get_streaminfo(self):
def clean_tag(tag):
if tag[0] == "_":
return tag[1:]
else:
return tag
chansub = self._authenticate()
url = self.StreamInfoURL.format(self.channelname)
params = dict(b_id="true", group="", private_code="null",
p=int(random.random() * 999999),
channel_subscription=chansub, type="any")
self.logger.debug("Fetching stream info")
res = urlget(url, params=params)
data = res.text
# fix invalid xml
data = re.sub("<(\d+)", "<_\g<1>", data)
data = re.sub("</(\d+)", "</_\g<1>", data)
streams = {}
try:
dom = xml.dom.minidom.parseString(data)
except Exception as err:
raise PluginError(("Unable to parse config XML: {0})").format(err))
nodes = dom.getElementsByTagName("nodes")[0]
if len(nodes.childNodes) == 0:
return streams
self.logger.debug("Verifying SWF: {0}", self.SWFURL)
swfhash, swfsize = swfverify(self.SWFURL)
for node in nodes.childNodes:
info = {}
for child in node.childNodes:
info[child.tagName] = self._get_node_text(child)
stream = RTMPStream(self.session, {
"rtmp": ("{0}/{1}").format(info["connect"], info["play"]),
"swfUrl": self.SWFURL,
"swfhash": swfhash,
"swfsize": swfsize,
"live": True
})
sname = clean_tag(node.tagName)
if "token" in info:
stream.params["jtv"] = info["token"]
else:
self.logger.warning("No token found for stream {0}, this stream may fail to play", sname)
streams[sname] = stream
return streams
def _get_streams(self):
self.channelname = self._get_channel_name(self.url)
if not self.channelname:
raise NoStreamsError(self.url)
return self._get_streaminfo()
__plugin__ = JustinTV
|
