def __init__(self, parent_id, id):
BackendItem.__init__(self)
# the ids as above
self.parent_id = parent_id
self.id = id
# we never have a different name anyway
self.name = 'LOLCats'
# but we need to set it to a certain mimetype to explain it, that we
# contain 'children'.
self.mimetype = 'directory'
# As we are updating our data periodically, we increase this value so
# that our clients can check easier if something has changed since their
# last request.
self.update_id = 0
# that is where we hold the children
self.children = []
# and we need to give a DIDLLite again. This time we want to be
# understood as 'Container'.
self.item = DIDLLite.Container(id, parent_id, self.name)
self.item.childCount = None # will be set as soon as we have images
def __init__(self, store, id, name):
BackendItem.__init__(self)
self.store = store
self.id = 'artist.%d' % int(id)
self.name = name
self.children = {}
self.sorted_children = None
def __init__(self, parent_id, id, title, url):
BackendItem.__init__(self)
self.parentid = parent_id # used to be able to 'go back'
self.update_id = 0
self.id = id # each item has its own and unique id
self.location = url # the url of the picture
self.name = title # the title of the picture. Inside
# coherence this is called 'name'
# Item.item is a special thing. This is used to explain the client what
# kind of data this is. For e.g. A VideoItem or a MusicTrack. In our
# case, we have an image.
self.item = DIDLLite.ImageItem(id, parent_id, self.name)
# each Item.item has to have one or more Resource objects
# these hold detailed information about the media data
# and can represent variants of it (different sizes, transcoded formats)
res = DIDLLite.Resource(self.location, 'http-get:*:image/jpeg:*')
res.size = None # FIXME: we should have a size here
# and a resolution entry would be nice too
self.item.res.append(res)
def __init__(self, item_data, container):
BackendItem.__init__(self)
self.item_data = item_data
self.container = container
self.sub_id = item_data["sub_id"]
self.storage_id = "track-%s$%s" % (self.sub_id, container.get_id())
self.__class__.next_sn += 1
self.sort_key = self.__class__.next_sn
track_number = None
m = re.match(
r"^song\.(\d+)\s+.*$",
_htmlparser.unescape(item_data["title"]),
re.I,
)
if m:
track_number, = m.groups()
title = _htmlparser.unescape(item_data["sub_title"])
self.name = title
self.title = title
self.originalTrackNumber = track_number
self.artist = _htmlparser.unescape(item_data["artist"])
self.album = _htmlparser.unescape(item_data["wiki_title"])
self.cover = item_data["cover"]["large"]
self.duration = item_data["stream_time"]
self.duration_seconds = int(item_data["stream_length"])
if not re.match(r"^\d{2}:\d{2}:\d{2}(?:\.\d+)?", self.duration):
self.duration = "0:" + self.duration # Add hour part
self.mimetype = "audio/mpeg"
self.item = None
def __init__(self, store,
id, parent_id,
file, title,
date, duration,
mimetype):
BackendItem.__init__(self)
self.store = store
self.id = 'recording.%s' % id
self.parent_id = parent_id
self.real_id = id
path = unicode(file)
# make sure path is an absolute local path (and not an URL)
if path.startswith("file://"):
path = path[7:]
self.location = FilePath(path)
self.title = unicode(title)
self.mimetype = str(mimetype)
self.date = datetime.fromtimestamp(int(date))
self.duration = int(duration)
try:
self.size = self.location.getsize()
except Exception, msg:
self.size = 0
def __init__(self, store,
id, parent_id,
file, title,
duration, \
size, mimetype):
BackendItem.__init__(self)
self.store = store
self.id = 'video.%d' % int(id)
self.parent_id = parent_id
self.path = unicode(file)
duration = str(duration).strip()
duration = duration.split('.')[0]
if len(duration) == 0:
duration = 0
seconds = int(duration)
hours = seconds / 3600
seconds = seconds - hours * 3600
minutes = seconds / 60
seconds = seconds - minutes * 60
self.duration = ("%d:%02d:%02d") % (hours, minutes, seconds)
self.title = unicode(title)
self.cover = None
self.mimetype = str(mimetype)
self.size = int(size)
self.url = self.store.urlbase + str(self.id)
def __init__(self, title, stream_url, mimetype):
BackendItem.__init__(self)
self.name = title
self.stream_url = stream_url
self.mimetype = mimetype
self.url = stream_url
self.item = None
def __init__(self, *args, **kwargs):
BackendItem.__init__(self, *args, **kwargs)
self._row = args[0]
self._store = args[1]
self._db = self._store.db
self.title = self._row.Name
if self.title:
self.title = self.title.encode("utf-8")
def __init__(self, title, url, status=None, viewers=0, created_at=None, preview_url=None): BackendItem.__init__(self) self.name = title self.status = status self.mimetype = MPEG_MIME self.created_at = created_at self.preview_url = preview_url self.viewers = viewers self.location = LiveStreamerProxyResource(url, 'best')
def __init__(self, store, id, title, artist):
BackendItem.__init__(self)
self.store = store
self.id = 'album.%d' % int(id)
self.name = unicode(title)
self.artist = unicode(artist)
self.cover = None
self.children = {}
self.sorted_children = None
def __init__(self, *args, **kwargs):
BackendItem.__init__(self, *args, **kwargs)
self._row = args[0]
self._db = args[1]
self.itemID = self._row.TrackID
self.title = self._row.Title
self.track_nr = self._row.TrackNumber
self.location = self._row.Uri
self.playlist = kwargs.get("playlist")
def __init__(self, *args, **kwargs):
BackendItem.__init__(self, *args, **kwargs)
self._row = args[0]
self._db = args[1]
self._local_music_library_id = args[2]
self.musicbrainz_id = self._row.MusicBrainzID
self.itemID = self._row.ArtistID
self.name = self._row.Name or ''
if self.name:
self.name = self.name.encode("utf-8")
def __init__(self, outline):
BackendItem.__init__(self)
self.preset_id = outline.get('preset_id')
self.name = outline.get('text')
self.mimetype = DEFAULT_MIMETYPE
self.stream_url = outline.get('URL')
self.image = outline.get('image')
#self.location = PlaylistStreamProxy(self.stream_url)
#self.url = self.stream_url
self.item = None
def __init__(self, device_name="/dev/cdrom", track_number=1, artist="Unknown", title="Unknown"):
BackendItem.__init__(self)
self.device_name = device_name
self.track_number = track_number
self.artist = artist
self.title = title
self.mimetype = TRACK_MIMETYPE
self.fourth_field = TRACK_FOURTH_FIELD
self.item = None
self.pipeline = PLAY_TRACK_GST_PIPELINE % (self.device_name, self.track_number)
self.location = GStreamerPipeline(self.pipeline, self.mimetype)
def __init__(self, id, parent_id, name, store=None, \
children_callback=None):
BackendItem.__init__(self)
self.id = id
self.parent_id = parent_id
self.name = name
self.mimetype = 'directory'
self.update_id = 0
self.children = []
self.item = DIDLLite.Container(id, parent_id, self.name)
self.item.childCount = None # self.get_child_count()
def __init__(self, *args, **kwargs):
BackendItem.__init__(self, *args, **kwargs)
self._row = args[0]
self._db = args[1]
self.artist = args[2]
self.itemID = self._row.AlbumID
self.title = self._row.Title
self.cover = get_cover_path(self.artist.name, self.title)
if self.title:
self.title = self.title.encode("utf-8")
self.musicbrainz_id = self._row.MusicBrainzID
self.cd_count = 1
def __init__(self, parent_id, id, title, url):
BackendItem.__init__(self)
self.parent_id = parent_id
self.id = id
self.location = url
self.name = title
self.duration = None
self.size = None
self.mimetype = 'audio/mpeg'
self.description = None
self.item = None
def __init__(self, parent_id, urlbase, id=None, name=None, cover=None,
url=None):
BackendItem.__init__(self)
self.parentid = parent_id
self.id = id
self.name = name
self.cover = cover
if(len(urlbase) and urlbase[-1] != '/'):
urlbase += '/'
self.url = urlbase + str(self.id)
self.location = AppleTrailerProxy(url)
self.item = DIDLLite.VideoItem(id, parent_id, self.name)
self.item.albumArtURI = self.cover
def __init__(self, parent_id, id, name):
BackendItem.__init__(self)
self.parent_id = parent_id
self.id = id
self.name = name
self.mimetype = "directory"
self.update_id = 0
self.children = []
self.item = DIDLLite.Container(id, parent_id, self.name)
self.item.childCount = None # will be set as soon as we have images
def __init__(self, movie, store, title=None, url=None):
BackendItem.__init__(self)
self.movie_id = 'UNK'
if movie.find('./id') is not None:
self.movie_id = movie.find('./id').text
self.title = movie.find('./title').text
self.baseFilename = movie.find('./baseFilename').text
self.plot = movie.find('./plot').text
self.outline = movie.find('./outline').text
self.posterFilename = movie.find('./posterFile').text
self.thumbnailFilename = movie.find('./thumbnail').text
self.rating = movie.find('./rating').text
self.director = movie.find('./director').text
self.genres = movie.findall('./genres/genre')
self.actors = movie.findall('./cast/actor')
self.year = movie.find('year').text
self.audioChannels = movie.find('audioChannels').text
self.resolution = movie.find('resolution').text
self.language = movie.find('language').text
self.season = movie.find('season').text
if title is not None:
self.upnp_title = title
else:
self.upnp_title = self.title
if url is not None:
self.movie_url = url
else:
self.movie_url = movie.find('./files/file/fileURL').text
self.posterURL = "%s/%s" % (store.jukebox_url, self.posterFilename)
self.thumbnailURL = "%s/%s" % (store.jukebox_url, self.thumbnailFilename)
#print self.movie_id, self.title, self.url, self.posterURL
self.str_genres = []
for genre in self.genres:
self.str_genres.append(genre.text)
self.str_actors = []
for actor in self.actors:
self.str_actors.append(actor.text)
url_mimetype, _ = mimetypes.guess_type(self.movie_url, strict=False)
if url_mimetype is None:
url_mimetype = "video"
self.name = self.title
self.duration = None
self.size = None
self.mimetype = url_mimetype
self.item = None
def __init__(self, external_id, title, url, mimetype, entry, store):
BackendItem.__init__(self)
self.external_id = external_id
self.name = title
self.duration = None
self.size = None
self.mimetype = mimetype
self.description = None
self.date = None
self.item = None
self.youtube_entry = entry
self.store = store
def extractDataURL(url, quality):
if (quality == 'hd'):
format = '22'
else:
format = '18'
kwargs = {
'usenetrc': False,
'quiet': True,
'forceurl': True,
'forcetitle': False,
'simulate': True,
'format': format,
'outtmpl': u'%(id)s.%(ext)s',
'ignoreerrors': True,
'ratelimit': None,
}
if len(self.store.login) > 0:
kwargs['username'] = self.store.login
kwargs['password'] = self.store.password
fd = FileDownloader(kwargs)
youtube_ie = YoutubeIE()
fd.add_info_extractor(YoutubePlaylistIE(youtube_ie))
fd.add_info_extractor(MetacafeIE(youtube_ie))
fd.add_info_extractor(youtube_ie)
deferred = fd.get_real_urls([url])
return deferred
#self.location = VideoProxy(url, self.external_id,
# store.proxy_mode,
# store.cache_directory, store.cache_maxsize, store.buffer_size,
# extractDataURL, quality=self.store.quality)
self.location = TestVideoProxy(url, self.external_id,
store.proxy_mode,
store.cache_directory, store.cache_maxsize, store.buffer_size,
extractDataURL, quality=self.store.quality)
def __init__(self, parent_id, store, id, name, author, author_image):
BackendItem.__init__(self)
self.parent_id = parent_id
self.update_id = 0
self.store = store
self.id = id
self.name = name
self.author = author
self.author_image = author_image
self.tracks = []
self.mimetype = "directory"
def __init__(self, store, id, obj, parent):
BackendItem.__init__(self)
self.parent = parent
self.id = id
self.name = obj.get('name')
self.mimetype = obj.get('mimetype')
self.description = None
self.date = None
self.item = None
self.duration = None
self.store = store
self.url = self.store.urlbase + str(self.id)
self.stream_url = obj.get('url')
self.location = ProxyStream(self.stream_url)
def __init__(self, id, store, parent_id, title):
BackendItem.__init__(self)
self.url = store.urlbase + str(id)
self.parent_id = parent_id
self.id = id
self.name = title
self.mimetype = 'directory'
self.update_id = 0
self.children = []
self.item = DIDLLite.Container(self.id, self.parent_id, self.name)
self.item.childCount = 0
self.sorted = False
def __init__(self, id, store, parent_id, title):
BackendItem.__init__(self)
self.url = store.urlbase + str(id)
self.parent_id = parent_id
self.id = id
self.name = title
self.mimetype = 'directory'
self.update_id = 0
self.children = []
self.item = DIDLLite.Container(self.id, self.parent_id, self.name)
self.item.childCount = 0
self.sorted = False
def __init__(self, store,
id, parent_id,
name, url, network,
mimetype):
BackendItem.__init__(self)
self.store = store
self.id = 'channel.%s' % id
self.parent_id = parent_id
self.real_id = id
self.name = unicode(name)
self.network = unicode(network)
self.stream_url = url
self.mimetype = str(mimetype)
def __init__(self, id, parent_id, name, children_callback=None, store=None,
play_container=False):
BackendItem.__init__(self)
self.id = id
self.parent_id = parent_id
self.name = name
self.mimetype = 'directory'
self.store = store
self.play_container = play_container
self.update_id = 0
if children_callback != None:
self.children = children_callback
else:
self.children = []
def __init__(self, store,
id, parent_id,
name, url, network,
mimetype):
BackendItem.__init__(self)
self.store = store
self.id = 'channel.%s' % id
self.parent_id = parent_id
self.real_id = id
self.name = str(name)
self.network = str(network)
self.stream_url = url
self.mimetype = str(mimetype)
def __init__(self, id, obj, parent, mimetype, urlbase, UPnPClass, update=False):
BackendItem.__init__(self)
self.id = id
self.name = obj.get('title') # .encode('utf-8')
if self.name == None:
self.name = obj.get('name')
if self.name == None:
self.name = id
self.mimetype = mimetype
self.gallery2_id = obj.get('gallery2_id')
self.parent = parent
if parent:
parent.add_child(self, update=update)
if parent == None:
parent_id = -1
else:
parent_id = parent.get_id()
self.item = UPnPClass(id, parent_id, self.name)
if isinstance(self.item, Container):
self.item.childCount = 0
self.child_count = 0
self.children = None
if(len(urlbase) and urlbase[-1] != '/'):
urlbase += '/'
if parent == None:
self.gallery2_url = None
self.url = urlbase + str(self.id)
elif self.mimetype == 'directory':
#self.gallery2_url = parent.store.get_url_for_album(self.gallery2_id)
self.url = urlbase + str(self.id)
else:
self.gallery2_url = parent.store.get_url_for_image(self.gallery2_id)
self.url = urlbase + str(self.id)
self.location = ProxyGallery2Image(self.gallery2_url)
if self.mimetype == 'directory':
self.update_id = 0
else:
res = Resource(self.gallery2_url, 'http-get:*:%s:*' % self.mimetype)
res.size = None
self.item.res.append(res)
def __init__(
self,
store,
id,
parent_id,
file,
title,
artist,
album,
genre,
duration,
track_number,
size,
mimetype,
):
BackendItem.__init__(self)
self.store = store
self.id = 'song.%d' % int(id)
self.parent_id = parent_id
self.path = str(file)
duration = str(duration).strip()
duration = duration.split('.')[0]
if len(duration) == 0:
duration = 0
seconds = int(duration)
hours = seconds / 3600
seconds = seconds - hours * 3600
minutes = seconds / 60
seconds = seconds - minutes * 60
self.duration = f'{hours:d}:{minutes:02d}:{seconds:02d}'
self.bitrate = 0
self.title = str(title)
self.artist = str(artist)
self.album = str(album)
self.genre = str(genre)
track_number = str(track_number).strip()
if len(track_number) == 0:
track_number = 1
self.track_nr = int(track_number)
self.cover = None
self.mimetype = str(mimetype)
self.size = int(size)
self.url = self.store.urlbase + str(self.id)
def __init__(self, store, element):
BackendItem.__init__(self)
self.store = store
self.ampache_id = element.get('id')
self.id = 'artist.%d' % int(element.get('id'))
try:
self.count_albums = int(element.find('albums').text)
except:
self.count_albums = None
try:
self.count_songs = int(element.find('songs').text)
except:
self.count_songs = None
self.name = element.find('name').text
def __init__(self, parent_id, id, title=None, url=None,
duration=None, size=None):
BackendItem.__init__(self)
self.parentid = parent_id
self.update_id = 0
self.id = id
self.location = url
self.name = title
self.item = DIDLLite.VideoItem(id, parent_id, self.name)
res = DIDLLite.Resource(self.location, 'http-get:*:video/mp4:*') # FIXME should be video/x-m4a
res.size = size
res.duration = duration
self.item.res.append(res)
def __init__(self, id, parent_id, name, store=None, children_callback=None, container_class=DIDLLite.Container):
BackendItem.__init__(self)
self.id = id
self.parent_id = parent_id
self.name = name
self.mimetype = 'directory'
self.item = container_class(id, parent_id, self.name)
self.item.childCount = 0
self.update_id = 0
if children_callback != None:
self.children = children_callback
else:
self.children = util.OrderedDict()
if store != None:
self.get_url = lambda: store.urlbase + str(self.id)
def __init__(self, parent_id, store, id, title, artist_id, artist, albumArtURI):
BackendItem.__init__(self)
self.parent_id = parent_id
self.update_id = 0
self.id = id
self.title = title
self.artist = artist
self.artist_id = artist_id
self.store = store
self.albumArtURI = albumArtURI
self.name = self.title
self.tracks = {}
self.mimetype = "directory"
def __init__(self, id, parent_id, name, store=None, children_callback=None, container_class=DIDLLite.Container):
BackendItem.__init__(self)
self.id = id
self.parent_id = parent_id
self.name = name
self.mimetype = 'directory'
self.item = container_class(id, parent_id, self.name)
self.item.childCount = 0
self.update_id = 0
if children_callback != None:
self.children = children_callback
else:
self.children = util.OrderedDict()
if store != None:
self.get_url = lambda: store.urlbase + str(self.id)
def __init__(self, name, description, url, thumbnail_url, store):
BackendItem.__init__(self)
self.name = name
self.duration = None
self.size = None
self.mimetype = "video"
self.url = None
self.video_url = url
self.thumbnail_url = thumbnail_url
self.description = description
self.date = None
self.item = None
self.location = TestVideoProxy(self.video_url, hash(self.video_url),
store.proxy_mode, store.cache_directory,
store.cache_maxsize, store.buffer_size)
def __init__(self,
title,
url,
status=None,
viewers=0,
created_at=None,
preview_url=None):
BackendItem.__init__(self)
self.name = title
self.status = status
self.mimetype = MPEG_MIME
self.created_at = created_at
self.viewers = viewers
self.url = url
self.preview_url = preview_url
self.location = LiveStreamerProxyResource(url, 'best')
self.parent = None
def __init__(self, parent, id, title, location, url):
BackendItem.__init__(self)
self.parent = parent
self.id = id
self.location = location
self.url = url
self.name = title
self.duration = None
self.size = None
self.mimetype = None
self.fourth_field = '*'
self.description = None
self.date = None
self.upnp_class = DIDLLite.Item
self.item = None
def __init__(self, store, element):
BackendItem.__init__(self)
self.store = store
self.id = 'song.%d' % int(element.get('id'))
self.parent_id = 'album.%d' % int(element.find('album').get('id'))
self.url = element.find('url').text
seconds = int(element.find('time').text)
hours = seconds / 3600
seconds = seconds - hours * 3600
minutes = seconds / 60
seconds = seconds - minutes * 60
self.duration = ("%d:%02d:%02d") % (hours, minutes, seconds)
self.bitrate = 0
self.title = element.find('title').text
self.artist = element.find('artist').text
self.album = element.find('album').text
try:
self.genre = element.find('genre').text
except:
self.genre = None
self.track_nr = element.find('track').text
try:
self.cover = element.find('art').text
except:
self.cover = None
self.mimetype = None
try:
self.mimetype = element.find('mime').text
except:
self.mimetype, _ = mimetypes.guess_type(self.url, strict=False)
if self.mimetype == None:
self.mimetype = "audio/mpeg"
try:
self.size = int(element.find('size').text)
except:
self.size = 0
if self.store.proxy == True:
self.location = ProxySong(self.url)
def __init__(self,
id,
obj,
parent,
mimetype,
urlbase,
UPnPClass,
update=False):
BackendItem.__init__(self)
self.id = id
if mimetype == 'directory':
self.name = obj
self.mimetype = mimetype
else:
self.name = obj.get('name')
self.mimetype = mimetype
self.parent = parent
if parent:
parent.add_child(self, update=update)
if parent == None:
parent_id = -1
else:
parent_id = parent.get_id()
self.item = UPnPClass(id, parent_id, self.name)
if isinstance(self.item, Container):
self.item.childCount = 0
self.children = []
if (len(urlbase) and urlbase[-1] != '/'):
urlbase += '/'
if self.mimetype == 'directory':
self.url = urlbase + str(self.id)
else:
self.url = obj.get('url')
if self.mimetype == 'directory':
self.update_id = 0
else:
res = Resource(self.url, obj.get('protocol'))
res.size = None
self.item.res.append(res)
def __init__(self,
device_name='/dev/cdrom',
track_number=1,
artist='Unknown',
title='Unknown'):
BackendItem.__init__(self)
self.device_name = device_name
self.track_number = track_number
self.artist = artist
self.title = title
self.size = None
self.mimetype = TRACK_MIMETYPE
self.fourth_field = TRACK_FOURTH_FIELD
self.item = None
self.parent = None
self.pipeline = PLAY_TRACK_GST_PIPELINE % (self.device_name,
self.track_number)
self.location = GStreamerPipeline(self.pipeline, self.mimetype)
def __init__(self,
id,
parent_id,
name,
children_callback=None,
store=None,
play_container=False):
BackendItem.__init__(self)
self.id = id
self.parent_id = parent_id
self.name = name
self.mimetype = 'directory'
self.store = store
self.play_container = play_container
self.update_id = 0
if children_callback != None:
self.children = children_callback
else:
self.children = []
def __init__(self, store,
id, parent_id,
file, title, album,
date, width, height, \
size, mimetype):
BackendItem.__init__(self)
self.store = store
self.id = 'image.%d' % int(id)
self.parent_id = parent_id
self.path = unicode(file)
self.title = unicode(title)
self.album = unicode(album.strip())
self.mimetype = str(mimetype)
self.size = int(size)
self.url = self.store.urlbase + str(self.id)
def __init__(self, store, element):
BackendItem.__init__(self)
self.store = store
self.ampache_id = element.get('id')
self.id = f'tag.{int(element.get("id")):d}'
try:
self.count_albums = int(element.find('albums').text)
except Exception:
self.count_albums = None
try:
self.count_artists = int(element.find('artists').text)
except Exception:
self.count_artists = None
try:
self.count_songs = int(element.find('songs').text)
except Exception:
self.count_songs = None
self.name = element.find('name').text
def __init__(self, store,
id, parent_id,
file, title,
artist, album, genre, \
duration, \
track_number, \
size, mimetype):
BackendItem.__init__(self)
self.store = store
self.id = 'song.%d' % int(id)
self.parent_id = parent_id
self.path = unicode(file)
duration = str(duration).strip()
duration = duration.split('.')[0]
if len(duration) == 0:
duration = 0
seconds = int(duration)
hours = seconds / 3600
seconds = seconds - hours * 3600
minutes = seconds / 60
seconds = seconds - minutes * 60
self.duration = ("%d:%02d:%02d") % (hours, minutes, seconds)
self.bitrate = 0
self.title = unicode(title)
self.artist = unicode(artist)
self.album = unicode(album)
self.genre = unicode(genre)
track_number = str(track_number).strip()
if len(track_number) == 0:
track_number = 1
self.track_nr = int(track_number)
self.cover = None
self.mimetype = str(mimetype)
self.size = int(size)
self.url = self.store.urlbase + str(self.id)
def __init__(self, store, element):
BackendItem.__init__(self)
self.store = store
self.id = f'song.{int(element.get("id")):d}'
self.parent_id = f'album.{int(element.find("album").get("id")):d}'
self.url = element.find('url').text
seconds = int(element.find('time').text)
self.duration = time.strftime('%H:%M:%S', time.gmtime(seconds))
self.bitrate = 0
self.title = element.find('title').text
self.artist = element.find('artist').text
self.album = element.find('album').text
try:
self.genre = element.find('genre').text
except Exception:
self.genre = None
self.track_nr = element.find('track').text
try:
self.cover = element.find('art').text
except Exception:
self.cover = None
self.mimetype = None
try:
self.mimetype = element.find('mime').text
except Exception:
self.mimetype, _ = mimetypes.guess_type(self.url, strict=False)
if self.mimetype is None:
self.mimetype = "audio/mpeg"
try:
self.size = int(element.find('size').text)
except Exception:
self.size = 0
if self.store.proxy:
self.location = ProxySong(self.url)
def __init__(self, photo):
BackendItem.__init__(self)
# print photo
self.photo = photo
self.name = photo.summary.text
if self.name is None:
self.name = photo.title.text
self.duration = None
self.size = None
self.mimetype = photo.content.type
self.description = photo.summary.text
self.date = None
self.item = None
self.photo_url = photo.content.src
self.thumbnail_url = photo.media.thumbnail[0].url
self.url = None
self.location = PicasaProxy(self.photo_url)
def __init__(self, store, id, parent_id, file, title, date, duration,
mimetype):
BackendItem.__init__(self)
self.store = store
self.id = 'recording.%s' % id
self.parent_id = parent_id
self.real_id = id
path = unicode(file)
# make sure path is an absolute local path (and not an URL)
if path.startswith("file://"):
path = path[7:]
self.location = FilePath(path)
self.title = unicode(title)
self.mimetype = str(mimetype)
self.date = datetime.fromtimestamp(int(date))
self.duration = int(duration)
try:
self.size = self.location.getsize()
except Exception, msg:
self.size = 0
def __init__(self,
parent_id,
id,
title=None,
url=None,
duration=None,
size=None):
BackendItem.__init__(self)
self.parentid = parent_id
self.update_id = 0
self.id = id
self.location = url
self.name = title
self.item = DIDLLite.VideoItem(id, parent_id, self.name)
res = DIDLLite.Resource(
self.location,
'http-get:*:video/mp4:*') # FIXME should be video/x-m4a
res.size = size
res.duration = duration
self.item.res.append(res)
def __init__(
self,
object_id,
parent,
path,
mimetype,
urlbase,
UPnPClass,
update=False,
store=None,
):
BackendItem.__init__(self)
self.id = object_id
self.parent = parent
if parent:
parent.add_child(self, update=update)
if mimetype == 'root':
self.location = str(path)
else:
if mimetype == 'item' and path is None:
path = os.path.join(parent.get_realpath(), str(self.id))
# self.location = FilePath(unicode(path))
self.location = FilePath(path)
self.mimetype = mimetype
if urlbase[-1] != '/':
urlbase += '/'
self.url = urlbase + str(self.id)
self.store = store
if parent is None:
parent_id = -1
else:
parent_id = parent.get_id()
self.item = UPnPClass(object_id, parent_id, self.get_name())
if isinstance(self.item, Container):
self.item.childCount = 0
self.child_count = 0
self.children = []
self.sorted = False
self.caption = None
if mimetype in ['directory', 'root']:
self.update_id = 0
self.get_url = lambda: self.url
# self.item.searchable = True
# self.item.searchClass = 'object'
if (isinstance(self.location, FilePath)
and self.location.isdir() is True):
self.check_for_cover_art()
if getattr(self, 'cover', None):
_, ext = os.path.splitext(self.cover)
''' add the cover image extension to help clients
not reacting on the mimetype '''
self.item.albumArtURI = ''.join(
(urlbase, str(self.id), '?cover', str(ext)))
else:
self.get_url = lambda: self.url
if self.mimetype.startswith('audio/'):
if getattr(parent, 'cover', None):
_, ext = os.path.splitext(parent.cover)
''' add the cover image extension to help clients
not reacting on the mimetype '''
self.item.albumArtURI = ''.join(
(urlbase, str(self.id), '?cover', ext))
_, host_port, _, _, _ = urlsplit(urlbase)
if host_port.find(':') != -1:
host, port = tuple(host_port.split(':'))
else:
host = host_port
try:
size = self.location.getsize()
except Exception:
size = 0
if (self.store.server and self.store.server.coherence.config.get(
'transcoding', 'no') == 'yes'):
if self.mimetype in (
'application/ogg',
'audio/ogg',
'audio/x-wav',
'audio/x-m4a',
'application/x-flac',
):
new_res = Resource(
self.url + '/transcoded.mp3',
f'http-get:*:{"audio/mpeg"}:*',
)
new_res.size = None
# self.item.res.append(new_res)
if mimetype != 'item':
res = Resource(
'file://' + quote(self.get_path(), encoding='utf-8'),
f'internal:{host}:{self.mimetype}:*',
)
res.size = size
self.item.res.append(res)
if mimetype != 'item':
res = Resource(self.url, f'http-get:*:{self.mimetype}:*')
else:
res = Resource(self.url, 'http-get:*:*:*')
res.size = size
self.item.res.append(res)
''' if this item is of type audio and we want to add a transcoding
rule for it, this is the way to do it:
create a new Resource object, at least a 'http-get'
and maybe an 'internal' one too
for transcoding to wav this looks like that
res = Resource(
url_for_transcoded audio,
'http-get:*:audio/x-wav:%s'% ';'.join(
['DLNA.ORG_PN=JPEG_TN']+simple_dlna_tags))
res.size = None
self.item.res.append(res)
'''
if (self.store.server and self.store.server.coherence.config.get(
'transcoding', 'no') == 'yes'):
if self.mimetype in (
'audio/mpeg',
'application/ogg',
'audio/ogg',
'audio/x-wav',
'audio/x-m4a',
'audio/flac',
'application/x-flac',
):
dlna_pn = 'DLNA.ORG_PN=LPCM'
dlna_tags = simple_dlna_tags[:]
# dlna_tags[1] = 'DLNA.ORG_OP=00'
dlna_tags[2] = 'DLNA.ORG_CI=1'
new_res = Resource(
self.url + '?transcoded=lpcm',
f'http-get:*:{"audio/L16;rate=44100;channels=2"}:'
f'{";".join([dlna_pn] + dlna_tags)}',
)
new_res.size = None
# self.item.res.append(new_res)
if self.mimetype != 'audio/mpeg':
new_res = Resource(
self.url + '?transcoded=mp3',
f'http-get:*:{"audio/mpeg"}:*',
)
new_res.size = None
# self.item.res.append(new_res)
''' if this item is an image and we want to add a thumbnail for it
we have to follow these rules:
create a new Resource object, at least a 'http-get'
and maybe an 'internal' one too
for an JPG this looks like that
res = Resource(url_for_thumbnail,
'http-get:*:image/jpg:%s'% ';'.join(
['DLNA.ORG_PN=JPEG_TN']+simple_dlna_tags))
res.size = size_of_thumbnail
self.item.res.append(res)
and for a PNG the Resource creation is like that
res = Resource(url_for_thumbnail,
'http-get:*:image/png:%s'% ';'.join(
simple_dlna_tags+['DLNA.ORG_PN=PNG_TN']))
if not hasattr(self.item, 'attachments'):
self.item.attachments = {}
self.item.attachments[key] = utils.StaticFile(
filename_of_thumbnail)
'''
if (self.mimetype in ('image/jpeg', 'image/png')
or self.mimetype.startswith('video/')):
try:
filename, mimetype, dlna_pn = _find_thumbnail(
self.get_path())
except NoThumbnailFound:
pass
except Exception:
self.warning(traceback.format_exc())
else:
dlna_tags = simple_dlna_tags[:]
dlna_tags[
3] = 'DLNA.ORG_FLAGS=00f00000000000000000000000000000'
hash_from_path = str(id(filename))
new_res = Resource(
self.url + '?attachment=' + hash_from_path,
f'http-get:*:{mimetype}:'
f'{";".join([dlna_pn] + dlna_tags)}',
)
new_res.size = os.path.getsize(filename)
self.item.res.append(new_res)
if not hasattr(self.item, 'attachments'):
self.item.attachments = {}
self.item.attachments[hash_from_path] = utils.StaticFile(
filename)
if self.mimetype.startswith('video/'):
# check for a subtitles file
caption, _ = os.path.splitext(self.get_path())
caption = caption + '.srt'
if os.path.exists(caption):
hash_from_path = str(id(caption))
mimetype = 'smi/caption'
new_res = Resource(
self.url + '?attachment=' + hash_from_path,
f'http-get:*:{mimetype}:{"*"}',
)
new_res.size = os.path.getsize(caption)
self.caption = new_res.data
self.item.res.append(new_res)
if not hasattr(self.item, 'attachments'):
self.item.attachments = {}
self.item.attachments[hash_from_path] = utils.StaticFile(
caption,
defaultType=mimetype,
)
try:
# FIXME: getmtime is deprecated in Twisted 2.6
self.item.date = datetime.fromtimestamp(
self.location.getmtime())
except Exception:
self.item.date = None
