def test_set_image(self):
self.assertTrue(self.song.has_images)
fileobj = BytesIO(b"foo")
image = EmbeddedImage(fileobj, "image/jpeg", 10, 10, 8)
self.song.set_image(image)
image = self.song.get_primary_image()
self.assertTrue(image)
self.assertEqual(image.read(), b"foo")
self.assertTrue(self.song.has_images)
def test_set_image(self):
fileobj = cBytesIO(b"foo")
image = EmbeddedImage(fileobj, "image/jpeg", 10, 10, 8)
self.s.set_image(image)
self.assertTrue(self.s.has_images)
images = self.s.get_images()
self.assertEqual(len(images), 1)
self.assertEqual(images[0].mime_type, "image/")
self.assertEqual(images[0].read(), b"foo")
def test_set_image_no_tag(self):
f = mutagen.File(self.filename)
f.delete()
song = MP3File(self.filename)
fileobj = StringIO.StringIO("foo")
image = EmbeddedImage(fileobj, "image/jpeg", 10, 10, 8)
song.set_image(image)
song = MP3File(self.filename)
self.assertTrue(song.has_images)
def test_set_image_no_tag(self):
f = mutagen.File(self.filename)
f.delete()
song = self.KIND(self.filename)
fileobj = BytesIO(b"foo")
image = EmbeddedImage(fileobj, "image/jpeg", 10, 10, 8)
song.set_image(image)
song = self.KIND(self.filename)
self.assertTrue(song.has_images)
def test_set_image(self):
fileobj = StringIO.StringIO("foo")
image = EmbeddedImage(fileobj, "image/jpeg", 10, 10, 8)
self.assertFalse(self.song.has_images)
self.song.set_image(image)
self.assertTrue(self.song.has_images)
image = self.song.get_primary_image()
self.assertEqual(image.mime_type, "image/jpeg")
self.assertEqual(image.file.read(), "foo")
def get_primary_image(self):
"""Returns the primary embedded image"""
try:
audio = self.MutagenType(self["~filename"])
except EnvironmentError:
return None
pictures = []
for data in audio.get("metadata_block_picture", []):
try:
pictures.append(Picture(base64.b64decode(data)))
except (TypeError, FLACError):
pass
cover = None
for pic in pictures:
if pic.type == APICType.COVER_FRONT:
cover = pic
break
cover = cover or pic
if cover:
f = get_temp_cover_file(cover.data)
return EmbeddedImage(f, cover.mime, cover.width, cover.height,
cover.depth, cover.type)
cover = audio.get("coverart")
try:
cover = cover and base64.b64decode(cover[0])
except TypeError:
cover = None
if not cover:
self.has_images = False
return
mime = audio.get("coverartmime")
mime = (mime and mime[0]) or "image/"
f = get_temp_cover_file(cover)
return EmbeddedImage(f, mime)
def test_set_image(self):
fileobj = BytesIO(b"foo")
image = EmbeddedImage(fileobj, "image/jpeg", 10, 10, 8)
song = self.KIND(self.filename)
self.failIf(song.has_images)
song.set_image(image)
self.assertTrue(song.has_images)
song = self.KIND(self.filename)
self.assertTrue(song.has_images)
self.assertEqual(song.get_primary_image().mime_type, "image/jpeg")
def get_images(self):
"""Returns a list of embedded images"""
images = []
try:
tag = mutagen.id3.ID3(self["~filename"])
except Exception:
return images
for frame in tag.getall("APIC"):
f = get_temp_cover_file(frame.data)
images.append(EmbeddedImage(f, frame.mime, type_=frame.type))
images.sort(key=lambda c: c.sort_key)
return images
def get_primary_image(self):
"""Returns the primary embedded image or None"""
try:
tag = mutagen.asf.ASF(self["~filename"])
except Exception:
return
for image in tag.get("WM/Picture", []):
try:
(mime, desc, data, type_) = unpack_image(image.value)
except ValueError:
continue
if type_ == APICType.COVER_FRONT: # Only cover images
f = get_temp_cover_file(data)
return EmbeddedImage(f, mime, type_=type_)
def get_primary_image(self):
try:
tag = MP4(self["~filename"])
except Exception:
return
for cover in tag.get("covr", []):
if cover.imageformat == MP4Cover.FORMAT_JPEG:
mime = "image/jpeg"
elif cover.imageformat == MP4Cover.FORMAT_PNG:
mime = "image/png"
else:
mime = "image/"
f = get_temp_cover_file(cover)
return EmbeddedImage(f, mime)
def get_images(self):
images = super(FLACFile, self).get_images()
try:
tag = FLAC(self["~filename"])
except EnvironmentError:
return images
for cover in tag.pictures:
fileobj = get_temp_cover_file(cover.data)
images.append(
EmbeddedImage(fileobj, cover.mime, cover.width, cover.height,
cover.depth, cover.type))
images.sort(key=lambda c: c.sort_key)
return images
def get_images(self):
images = []
try:
tag = mutagen.asf.ASF(self["~filename"])
except Exception:
return images
for image in tag.get("WM/Picture", []):
try:
(mime, desc, data, type_) = unpack_image(image.value)
except ValueError:
continue
f = get_temp_cover_file(data)
images.append(EmbeddedImage(f, mime, type_=type_))
images.sort(key=lambda c: c.sort_key)
return images
def get_primary_image(self):
"""Returns the primary embedded image"""
try:
tag = FLAC(self["~filename"])
except EnvironmentError:
return None
covers = tag.pictures
if not covers:
return super(FLACFile, self).get_primary_image()
covers.sort(key=lambda c: APICType.sort_key(c.type))
cover = covers[0]
fileobj = get_temp_cover_file(cover.data)
return EmbeddedImage(fileobj, cover.mime, cover.width, cover.height,
cover.depth, cover.type)
def parse_cover(key, value):
"""Returns a EmbeddedImage or None"""
# http://www.hydrogenaud.io/forums/index.php?showtopic=40603
cover_type = get_cover_type(key, value)
if cover_type is None:
return
parts = value.value.split(b"\x00", 1)
if len(parts) != 2:
return
f = get_temp_cover_file(parts[-1])
if not f:
return
return EmbeddedImage(f, "image/", type_=cover_type)
def get_primary_image(self):
"""Returns the primary embedded image"""
try:
tag = mutagen.id3.ID3(self["~filename"])
except Exception:
return
# get the APIC frame with type == 3 (cover) or the first one
cover = None
for frame in tag.getall("APIC"):
cover = cover or frame
if frame.type == APICType.COVER_FRONT:
cover = frame
break
if cover:
f = get_temp_cover_file(cover.data)
return EmbeddedImage(f, cover.mime, type_=cover.type)
def get_images(self):
images = []
try:
tag = MP4(self["~filename"])
except Exception:
return []
for cover in tag.get("covr", []):
if cover.imageformat == MP4Cover.FORMAT_JPEG:
mime = "image/jpeg"
elif cover.imageformat == MP4Cover.FORMAT_PNG:
mime = "image/png"
else:
mime = "image/"
f = get_temp_cover_file(cover)
images.append(EmbeddedImage(f, mime))
return images
def test_set_image(self):
data = _get_jpeg()
song = self.MutagenType(self.filename)
song["coverart"] = base64.b64encode(data).decode("ascii")
song["coverartmime"] = "image/jpeg"
song.save()
fileobj = cBytesIO(b"foo")
image = EmbeddedImage(fileobj, "image/jpeg", 10, 10, 8)
song = self.QLType(self.filename)
self.assertTrue(song.has_images)
self.assertTrue(song.get_primary_image())
self.assertTrue(song.has_images)
song.set_image(image)
self.assertTrue(song.has_images)
self.assertEqual(song.get_primary_image().width, 10)
song = self.MutagenType(self.filename)
self.assertTrue("coverart" not in song)
self.assertTrue("coverartmime" not in song)
