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, 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, 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, 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, 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