예제 #1
0
    def _write_flac_tags(self, path, track, tags=None):
        if "DATA" in track:
            track = track["DATA"]

        if not tags:
            tags = self.get_track_tags(track)

        audio = File(path)
        audio.delete()

        cover = tags["_albumart"]
        del tags["_albumart"]

        if cover:
            pic = mutagen.flac.Picture()
            pic.data = cover["image"]

            audio.clear_pictures()
            audio.add_picture(pic)

        for key, val in tags.items():
            if val:
                audio[key] = str(val)
        audio.save()

        return True
예제 #2
0
파일: Qo-DL.py 프로젝트: 19h/Qo-DL
def add_flac_cover(filename, albumart):
    audio = File(str(filename))
    image = Picture()
    image.type = 3
    image.mime = "image/jpeg"
    with open(albumart, 'rb') as f:
        image.data = f.read()
        audio.add_picture(image)
        audio.save()
예제 #3
0
def writeAlbumCover(songPath: str, coverPath: str, picData=None):
    """ 给音频文件写入封面
    Parameters
    ----------
    songPath: 音频文件路径\n
    coverPath: 封面图片路径\n
    picData: 封面图片二进制数据
    """
    id_card = File(songPath)
    # 读取封面数据
    if not picData:
        with open(coverPath, 'rb') as f:
            picData = f.read()
    # 获取音频数据和图片数据后缀名
    audioSuffix = id_card.mime[0].split('/')[-1]
    try:
        picSuffix = imghdr.what(None, picData)
    except:
        picSuffix = 'jpeg'
    mimeType = 'image/' + picSuffix
    # 开始写入封面
    if audioSuffix == 'mp3':
        keyName = 'APIC:'
        keyName_list = []
        # 获取可能已经存在的封面键名
        for key in id_card.tags.keys():
            if key.startswith('APIC'):
                keyName = key
                keyName_list.append(key)
        # 弹出所有旧标签才能写入新数据
        for key in keyName_list:
            id_card.pop(key)
        id_card[keyName] = APIC(encoding=0,
                                mime=mimeType,
                                type=3,
                                desc='',
                                data=picData)
    elif audioSuffix == 'flac':
        # 创建Picture实例
        picture = Picture()
        # 设置属性值
        picture.mime = mimeType
        picture.data = picData
        picture.type = 0
        # 清除原来的图片数据
        id_card.clear_pictures()
        # 添加图片
        id_card.add_picture(picture)
    elif audioSuffix == 'mp4':
        try:
            id_card['covr'][0] = picData
        except:
            id_card['covr'] = [picData]  # 没有键时需要创建一个
    id_card.save()
예제 #4
0
def writeAlbumCov(file):
	if file.endswith('c'):
		audio = File(file)
		image = Picture()
		image.type = 3
		mime = "image/jpeg"
		with open("cover.jpg", 'rb') as f:
			image.data = f.read()
			audio.clear_pictures()
			audio.add_picture(image)
			audio.save()
	else:
		audio = MP4(file)
		with open("cover.jpg", 'rb') as f:
			audio['covr'] = [MP4Cover(f.read(), imageformat = MP4Cover.FORMAT_JPEG)]
			audio.save(file)
def add_albumart(working_dir, folder_name, title):
    audio = File(os.path.join(working_dir, folder_name, f'{title}.flac'))

    image = Picture()
    image.type = 3

    mime = 'image/png'
    image.desc = 'front cover'

    # better than open(albumart, 'rb').read() ?
    with open(
            os.path.join(working_dir, folder_name, 'albumart', f'{title}.png'),
            'rb') as f:
        image.data = f.read()

    audio.add_picture(image)
    audio.save()
예제 #6
0
for d in glob.glob(directory + "/*"):
    # skip files in root directory
    if not os.path.isdir(d):
        continue

    cover = None
    # get the cover (use the first image found in directory)
    for f in glob.glob(d + "/*.jp*g"):
        cover = f
        break

    if not cover:
        print("no cover found in directory [%s]" % d)
        sys.exit(1)

    # scan for flac files
    for flac in glob.glob(d + "/*.flac"):
        # create mutagen picture object
        pic = Picture()

        # open cover file and store into flac file
        with open(cover, "rb") as c:
            # read raw picture data from cover file
            pic.data = c.read()

            mfile = File(flac)
            # remove old and add new cover
            mfile.clear_pictures()
            mfile.add_picture(pic)
            mfile.save()
예제 #7
0
def split_item(item, DIGITAL_FOLDER=mp3_folder, DROPBOX_COPY=False):    
    logging.info('BLOOOAAARRRRGHHGGGGHHHHH!!! (Please hold...)')
    audio = wave.open(item.path)
    audio.params = audio.getparams()

    # Load AudioSegment for encoded segments
    if item.digital_ext is not 'wav':
        audio_segment = AudioSegment.from_wav(item.path)

    # Loop through cues and write regions (assumes start and end markers)
    for i, track in enumerate(item.tracks):
        # Build track filename
        digital_track_name = '{0} - {1} - {2}'.format(item.digital_file_name, str(i + 1), track.title)
        digital_track_name = ''.join([c for c in digital_track_name if c.isalpha() or c.isdigit() or c in "'- ._()!@#$%^&*"]).rstrip('. ')
        digital_track_path = os.path.join(DIGITAL_FOLDER, digital_track_name) + '.' + item.digital_ext
        logging.info('Region {0} | {1} -> {2}'.format(i + 1, track.duration, digital_track_path))
        # Split, export track
        if 'wav' not in item.digital_ext:
            digital_track = audio_segment[(item.cues[i] / 44.1):(item.cues[i + 1] / 44.1)]
            tags = {'title':track.title, 'artist':item.artist, 'albumartist':item.artist, 'album':(item.album or item.artist), 'track':(i + 1)}
            digital_track.export(out_f=digital_track_path, format=item.digital_ext, bitrate='192k', tags=tags)
            # Add cover art
            if item.thumb and (item.digital_ext == 'mp3'):
                mutagen_audio = MP3(digital_track_path, ID3=ID3)
                try:
                    # Add ID3 tag if it doesn't exist
                    mutagen_audio.add_tags()
                except error:
                    pass
                mutagen_audio.tags.add(
                    APIC(
                        encoding=3, # 3 is for utf-8
                        mime='image/jpeg', # image/jpeg or image/png
                        type=3, # 3 is for the cover image
                        desc=u'Cover',
                        data=open(item.thumb_path, 'rb').read()
                    )
                )
                mutagen_audio.save()
            elif item.thumb and (item.digital_ext == 'flac'):
                mutagen_audio = File(digital_track_path)
                flac_image = Picture()
                flac_image.type = 3
                mime = 'image/jpeg'
                flac_image.desc = 'Cover'
                with open(item.thumb_path, 'rb') as f:
                    flac_image.data = f.read()
                mutagen_audio.add_picture(flac_image)
                mutagen_audio.save()
            else:
                logging.warning('No cover found for item {0}'.format(item.name))
        else:
            digital_track = wave.open(digital_track_path, 'w')
            digital_track.setparams(audio.params)  
            region_length = item.cues[i + 1] - item.cues[i]
            digital_track.writeframes(audio.readframes(region_length))
            digital_track.close()
        if DROPBOX_COPY:
            # Copy finished digital file to Dropbox order folder
            shutil.copy2(digital_track_path, item.dropbox_order_folder)
    audio.close()
예제 #8
0
파일: tagHelper.py 프로젝트: AIGMix/AIGPY
class TagTool(object):
    def __init__(self, filePath):
        if os.path.isfile(filePath) is False:
            return

        self._filepath = filePath
        self._ext = __extension__(filePath)
        self._handle = File(filePath)

        self.title = ''
        self.album = ''
        self.albumartist = ''
        self.artist = ''
        self.copyright = ''
        self.tracknumber = ''
        self.totaltrack = ''
        self.discnumber = ''
        self.totaldisc = ''
        self.genre = ''
        self.date = ''
        self.composer = ''
        self.isrc = ''
        self.lyrics = ''

        self.__load__()

    def save(self, coverPath: str = None):
        try:
            if 'mp3' in self._ext:
                return self.__saveMp3__(coverPath)
            if 'flac' in self._ext:
                return self.__saveFlac__(coverPath)
            if 'mp4' in self._ext or 'm4a' in self._ext:
                return self.__saveMp4__(coverPath)
            return False
        except Exception as e:
            return False, str(e)

    def addPic(self, converPath: str = None):
        try:
            self.__savePic__(converPath)
            self._handle.save()
            return True
        except Exception as e:
            return False, str(e)

    def addLyrics(self, lyrics: str = None):
        try:
            if 'mp3' in self._ext:
                self._handle.tags.add(
                    USLT(encoding=3,
                         lang=u'eng',
                         desc=u'desc',
                         text=__tryStr__(self.lyrics)))
            if 'flac' in self._ext:
                self._handle.tags['lyrics'] = __tryStr__(self.lyrics)
            if 'mp4' in self._ext or 'm4a' in self._ext:
                self._handle.tags['\xa9lyr'] = __tryStr__(self.lyrics)
            self._handle.save()
            return True
        except Exception as e:
            return False, str(e)

    def __load__(self):
        try:
            if 'mp3' in self._ext:
                return self.__getMp3__()
            if 'flac' in self._ext:
                return self.__getFlac__()
            if 'mp4' in self._ext or 'm4a' in self._ext:
                return self.__getMp4__()
        except:
            return

    def __saveMp3__(self, coverPath):
        if self._handle.tags is None:
            self._handle.add_tags()
        self._handle.tags.add(TIT2(encoding=3, text=self.title))
        self._handle.tags.add(TALB(encoding=3, text=self.album))
        # self._handle.tags.add(TOPE(encoding=3, text=self.albumartist))
        self._handle.tags.add(TPE1(encoding=3, text=self.artist))
        self._handle.tags.add(TCOP(encoding=3, text=self.copyright))
        self._handle.tags.add(TRCK(encoding=3, text=str(self.tracknumber)))
        # self._handle.tags.add(TRCK(encoding=3, text=self.discnum))
        self._handle.tags.add(TCON(encoding=3, text=self.genre))
        self._handle.tags.add(TDRC(encoding=3, text=self.date))
        self._handle.tags.add(TCOM(encoding=3, text=self.composer))
        self._handle.tags.add(TSRC(encoding=3, text=self.isrc))
        self._handle.tags.add(
            USLT(encoding=3, lang=u'eng', desc=u'desc', text=self.lyrics))
        self.__savePic__(coverPath)
        self._handle.save()
        return True

    def __getMp3__(self):
        if self._handle.tags is None:
            self._handle.add_tags()

    def __saveFlac__(self, coverPath):
        if self._handle.tags is None:
            self._handle.add_tags()
        self._handle.tags['title'] = self.title
        self._handle.tags['album'] = self.album
        self._handle.tags['albumartist'] = __tryList__(self.albumartist)
        self._handle.tags['artist'] = __tryList__(self.artist)
        self._handle.tags['copyright'] = __tryStr__(self.copyright)
        self._handle.tags['tracknumber'] = str(self.tracknumber)
        self._handle.tags['tracktotal'] = str(self.totaltrack)
        self._handle.tags['discnumber'] = str(self.discnumber)
        self._handle.tags['disctotal'] = str(self.totaldisc)
        self._handle.tags['genre'] = __tryStr__(self.genre)
        self._handle.tags['date'] = __tryStr__(self.date)
        self._handle.tags['composer'] = __tryStr__(self.composer)
        self._handle.tags['isrc'] = __tryStr__(self.isrc)
        self._handle.tags['lyrics'] = __tryStr__(self.lyrics)
        self.__savePic__(coverPath)
        self._handle.save()
        return True

    def __getFlac__(self):
        if self._handle.tags is None:
            return
        self.title = self.__getTagItem__('title')
        self.album = self.__getTagItem__('album')
        self.albumartist = self.__getTagItem__('albumartist')
        self.artist = self.__getTagItem__('artist')
        self.copyright = self.__getTagItem__('copyright')
        self.tracknumber = self.__getTagItem__('tracknumber')
        self.totaltrack = self.__getTagItem__('tracktotal')
        self.discnumber = self.__getTagItem__('discnumber')
        self.totaldisc = self.__getTagItem__('disctotal')
        self.genre = self.__getTagItem__('genre')
        self.date = self.__getTagItem__('date')
        self.composer = self.__getTagItem__('composer')
        self.isrc = self.__getTagItem__('isrc')
        self.lyrics = self.__getTagItem__('lyrics')

    def __saveMp4__(self, coverPath):
        self._handle.tags['\xa9nam'] = self.title
        self._handle.tags['\xa9alb'] = self.album
        self._handle.tags['aART'] = __tryList__(self.albumartist)
        self._handle.tags['\xa9ART'] = __tryList__(self.artist)
        self._handle.tags['cprt'] = __tryStr__(self.copyright)
        self._handle.tags['trkn'] = [[
            __tryInt__(self.tracknumber),
            __tryInt__(self.totaltrack)
        ]]
        self._handle.tags['disk'] = [[
            __tryInt__(self.discnumber),
            __tryInt__(self.totaldisc)
        ]]
        self._handle.tags['\xa9gen'] = __tryStr__(self.genre)
        self._handle.tags['\xa9day'] = __tryStr__(self.date)
        self._handle.tags['\xa9wrt'] = __tryList__(self.composer)
        self._handle.tags['\xa9lyr'] = __tryStr__(self.lyrics)
        self.__savePic__(coverPath)
        self._handle.save()
        return True

    def __getMp4__(self):
        self.title = self.__getTagItem__('\xa9nam')
        self.album = self.__getTagItem__('\xa9alb')
        self.albumartist = self.__getTagItem__('aART')
        self.artist = self.__getTagItem__('\xa9ART')
        self.copyright = self.__getTagItem__('\cprt')
        self.tracknumber = self.__getTagItem__('trkn')
        self.totaltrack = self.__getTagItem__('trkn')
        self.discnumber = self.__getTagItem__('disk')
        self.totaldisc = self.__getTagItem__('disk')
        self.genre = self.__getTagItem__('\xa9gen')
        self.date = self.__getTagItem__('\xa9day')
        self.composer = self.__getTagItem__('\xa9wrt')
        self.lyrics = self.__getTagItem__('\xa9lyr')

    def __getTagItem__(self, name):
        if name in self._handle.tags:
            return self._handle.tags[name]
        return ''

    def __savePic__(self, coverPath):
        data = __content__(coverPath)
        if data is None:
            return

        if 'flac' in self._ext:
            pic = flac.Picture()
            pic.data = data
            if '.jpg' in coverPath:
                pic.mime = u"image/jpeg"
            self._handle.clear_pictures()
            self._handle.add_picture(pic)

        if 'mp3' in self._ext:
            self._handle.tags.add(APIC(encoding=3, data=data))

        if 'mp4' in self._ext or 'm4a' in self._ext:
            pic = mp4.MP4Cover(data)
            self._handle.tags['covr'] = [pic]
예제 #9
0
파일: tagHelper.py 프로젝트: memoz/AIGPY
class TagTool(object):
    def __init__(self, filePath):
        if os.path.isfile(filePath) is False:
            return

        self._filepath = filePath
        self._ext = _getExtension(filePath)
        self._handle = File(filePath)

        self.title = ''
        self.album = ''
        self.albumartist = ''
        self.artist = ''
        self.copyright = ''
        self.tracknumber = ''
        self.totaltrack = ''
        self.discnumber = ''
        self.totaldisc = ''
        self.genre = ''
        self.date = ''
        self.composer = ''
        self.isrc = ''

    def save(self, coverPath=None):
        try:
            if 'mp3' in self._ext:
                return self._saveMp3(coverPath)
            if 'flac' in self._ext:
                return self._saveFlac(coverPath)
            if 'mp4' in self._ext or 'm4a' in self._ext:
                return self._saveMp4(coverPath)
            return False
        except:
            return False

    def _saveMp3(self, coverPath):
        self._handle.tags.add(TIT2(encoding=3, text=self.title))
        self._handle.tags.add(TALB(encoding=3, text=self.album))
        # self._handle.tags.add(TOPE(encoding=3, text=self.albumartist))
        self._handle.tags.add(TPE1(encoding=3, text=self.artist))
        self._handle.tags.add(TCOP(encoding=3, text=self.copyright))
        self._handle.tags.add(TRCK(encoding=3, text=str(self.tracknumber)))
        # self._handle.tags.add(TRCK(encoding=3, text=self.discnum))
        self._handle.tags.add(TCON(encoding=3, text=self.genre))
        self._handle.tags.add(TDRC(encoding=3, text=self.date))
        self._handle.tags.add(TCOM(encoding=3, text=self.composer))
        self._handle.tags.add(TSRC(encoding=3, text=self.isrc))
        self._savePic(coverPath)
        self._handle.save()
        return True

    def _saveFlac(self, coverPath):
        if self._handle.tags is None:
            self._handle.add_tags()
        self._handle.tags['title'] = self.title
        self._handle.tags['album'] = self.album
        self._handle.tags['albumartist'] = self.albumartist
        self._handle.tags['artist'] = self.artist
        self._handle.tags['copyright'] = _noneToEmptyString(self.copyright)
        self._handle.tags['tracknumber'] = str(self.tracknumber)
        self._handle.tags['tracktotal'] = str(self.totaltrack)
        self._handle.tags['discnumber'] = str(self.discnumber)
        self._handle.tags['disctotal'] = str(self.totaldisc)
        self._handle.tags['genre'] = _noneToEmptyString(self.genre)
        self._handle.tags['date'] = _noneToEmptyString(self.date)
        self._handle.tags['composer'] = _noneToEmptyString(self.composer)
        self._handle.tags['isrc'] = str(self.isrc)
        self._savePic(coverPath)
        self._handle.save()
        return True

    def _saveMp4(self, coverPath):
        self._handle.tags['\xa9nam'] = self.title
        self._handle.tags['\xa9alb'] = self.album
        self._handle.tags['aART'] = _getArrayStr(self.albumartist)
        self._handle.tags['\xa9ART'] = _getArrayStr(self.artist)
        self._handle.tags['cprt'] = _noneToEmptyString(self.copyright)
        self._handle.tags['trkn'] = [[_tryInt(self.tracknumber), _tryInt(self.totaltrack)]]
        self._handle.tags['disk'] = [[_tryInt(self.discnumber), _tryInt(self.totaldisc)]]
        self._handle.tags['\xa9gen'] = _noneToEmptyString(self.genre)
        self._handle.tags['\xa9day'] = _noneToEmptyString(self.date)
        self._handle.tags['\xa9wrt'] = _getArrayStr(self.composer)
        self._savePic(coverPath)
        self._handle.save()
        return True

    def _savePic(self, coverPath):
        data = _getFileData(coverPath)
        if data is None:
            return
        if 'flac' in self._ext:
            pic = flac.Picture()
            pic.data = data
            if pathHelper.getFileExtension(coverPath) == '.jpg':
                pic.mime = u"image/jpeg"
            self._handle.clear_pictures()
            self._handle.add_picture(pic)
        if 'mp3' in self._ext:
            self._handle.tags.add(APIC(encoding=3, data=data))
        if 'mp4' in self._ext or 'm4a' in self._ext:
            pic = mp4.MP4Cover(data)
            self._handle.tags['covr'] = [pic]
def update_picture(flac_file: mutagen.File, picture: mutagen.flac.Picture):
    flac_file.clear_pictures()
    flac_file.add_picture(picture)
예제 #11
0
    def process_a_file(self, input_path, output_dir):
        au_id = input_path.name

        if not au_id.isdigit():
            print(f'unexpected file: {input_path}')
            return

        au_id = int(au_id)

        file_kind = File(input_path)

        if isinstance(file_kind, MP4):
            suffix = '.m4a'
        elif isinstance(file_kind, FLAC):
            suffix = '.flac'
        elif file_kind is None:
            raise TypeError('unknown file kind')
        else:
            raise TypeError(
                f'unsupport file kind {file_kind.__class__.__name__}')

        audio_info = self.audio_cache.get(au_id)
        filename = f'{spilt_artist_str(audio_info["author"])[0]} - {audio_info["title"]}{suffix}'

        output_path = output_dir / filename

        if not self.overwrite and output_path.is_file():
            print(f'{filename} exists, skipped')
            return

        print(f'processing: {filename}')

        shutil.copyfile(input_path, output_path)

        album_id = audio_info['pgc_info']['pgc_menu']['menuId']
        album_info = self.album_cache.get(album_id)
        album_cover_url = album_info['menusRespones']['coverUrl']

        album_au_ids = list(map(lambda x: x['id'], album_info['songsList']))
        track_id = album_au_ids.index(au_id)
        assert album_cover_url == album_info['songsList'][track_id][
            'cover_url']

        album_cover_path = self.cover_cache.get(album_cover_url)
        if album_cover_path.suffix == '.jpg':
            image_format = AtomDataType.JPEG
        elif album_cover_path.suffix == '.png':
            image_format = AtomDataType.PNG
        else:
            raise TypeError(
                f'Unsupport format: {album_cover_path.suffix}, Only support jpg and png.'
            )

        with album_cover_path.open('rb') as fp:
            cover_image = fp.read()

        audio_file = File(output_path)

        if isinstance(audio_file, MP4):
            tags = {
                '\xa9nam':
                audio_info['title'],
                '\xa9alb':
                album_info['menusRespones']['title'],
                '\xa9ART':
                format_artist_list(spilt_artist_str(audio_info['author'])),
                '\xa9day':
                str(
                    get_year_from_timestamp(
                        album_info['menusRespones']['pbtime'])),
                'aART':
                format_artist_list(
                    spilt_artist_str(album_info['menusRespones']['mbnames'])),
                'trkn':
                [(track_id + 1, album_info['menusRespones']['songNum'])],
                'disk': [(1, 1)],
                'covr': [MP4Cover(cover_image, imageformat=image_format)],
            }
        elif isinstance(audio_file, FLAC):
            tags = {
                'ALBUM':
                album_info['menusRespones']['title'],
                'ARTIST':
                format_artist_list(spilt_artist_str(audio_info['author'])),
                'ALBUMARTIST':
                format_artist_list(
                    spilt_artist_str(album_info['menusRespones']['mbnames'])),
                'DATE':
                str(
                    get_year_from_timestamp(
                        album_info['menusRespones']['pbtime'])),
                'TITLE':
                audio_info['title'],
                'DISCNUMBER':
                '1',
                'DISCTOTAL':
                '1',
                'TRACKTOTAL':
                str(album_info['menusRespones']['songNum']),
                'TRACKNUMBER':
                str(track_id + 1),
            }

            picture = Picture()
            picture.data = cover_image
            picture.type = PictureType.COVER_FRONT

            audio_file.add_picture(picture)

        audio_file.update(tags)
        audio_file.save()
def split_item(item, digital_folder=digital_folder, dropbox_move=True):
    logging.info("BLOOOAAARRRRGHHGGGGHHHHH!!! (Please hold...)")
    audio = wave.open(item.path)
    audio.params = audio.getparams()

    # Load AudioSegment for encoded segments
    if item.digital_ext is not "wav":
        audio_segment = AudioSegment.from_wav(item.path)

    # Loop through cues and write regions (assumes start and end markers)
    for i, track in enumerate(item.tracks):
        # Build track filename
        digital_track_name = "{0} - {1} - {2}".format(item.digital_file_name, str(i + 1), track.title)
        digital_track_name = "".join(
            [c for c in digital_track_name if c.isalpha() or c.isdigit() or c in "'- ._()!@#$%^&*"]
        ).rstrip(". ")
        if dropbox_move:
            digital_track_path = os.path.join(item.dropbox_order_folder, digital_track_name) + "." + item.digital_ext
        else:
            digital_track_path = os.path.join(digital_folder, digital_track_name) + "." + item.digital_ext
        logging.info("Region {0} | {1} -> {2}".format(i + 1, track.duration, digital_track_path))
        # Split, export track
        if "wav" not in item.digital_ext:
            digital_track = audio_segment[(item.cues[i] / 44.1) : (item.cues[i + 1] / 44.1)]
            tags = {
                "title": track.title or "Track {0}".format(i + 1),
                "artist": item.artist,
                "albumartist": item.artist,
                "album": (item.album or item.artist),
                "track": (i + 1),
            }
            digital_track.export(
                out_f=digital_track_path, format=item.digital_ext, bitrate=item.bitrate, tags=tags, id3v2_version="3"
            )
            # Add cover art
            if item.thumb and (item.digital_ext == "mp3"):
                mutagen_audio = MP3(digital_track_path, ID3=ID3)
                try:
                    # Add ID3 tag if it doesn't exist
                    mutagen_audio.add_tags()
                except error:
                    pass
                mutagen_audio.tags.add(
                    APIC(
                        encoding=3,  # 3 is for utf-8
                        mime="image/jpeg",  # image/jpeg or image/png
                        type=3,  # 3 is for the cover image
                        desc=u"Cover",
                        data=open(item.thumb_path, "rb").read(),
                    )
                )
                mutagen_audio.save(v2_version=3)
            elif item.thumb and (item.digital_ext == "flac"):
                mutagen_audio = File(digital_track_path)
                flac_image = Picture()
                flac_image.type = 3
                mime = "image/jpeg"
                flac_image.desc = "Cover"
                with open(item.thumb_path, "rb") as f:
                    flac_image.data = f.read()
                mutagen_audio.add_picture(flac_image)
                mutagen_audio.save()
            else:
                logging.warning("No cover found for item {0}".format(item.name))
        else:
            digital_track = wave.open(digital_track_path, "w")
            digital_track.setparams(audio.params)
            region_length = item.cues[i + 1] - item.cues[i]
            digital_track.writeframes(audio.readframes(region_length))
            digital_track.close()
    audio.close()