bool SFB::Audio::Metadata::WriteMetadata(CFErrorRef *error)
{
bool result = _WriteMetadata(error);
if(result)
MergeChangedMetadataIntoMetadata();
return result;
}
void SFB::Audio::Metadata::MergeChangedMetadataIntoMetadata()
{
CFIndex count = CFDictionaryGetCount(mChangedMetadata);
CFTypeRef *keys = (CFTypeRef *)malloc(sizeof(CFTypeRef) * (size_t)count);
CFTypeRef *values = (CFTypeRef *)malloc(sizeof(CFTypeRef) * (size_t)count);
CFDictionaryGetKeysAndValues(mChangedMetadata, keys, values);
for(CFIndex i = 0; i < count; ++i) {
if(kCFNull == values[i])
CFDictionaryRemoveValue(mMetadata, keys[i]);
else
CFDictionarySetValue(mMetadata, keys[i], values[i]);
}
free(keys), keys = nullptr;
free(values), values = nullptr;
CFDictionaryRemoveAllValues(mChangedMetadata);
auto iter = std::begin(mPictures);
while(iter != std::end(mPictures)) {
auto picture = *iter;
if(AttachedPicture::ChangeState::Removed == picture->mState)
iter = mPictures.erase(iter);
else {
picture->MergeChangedMetadataIntoMetadata();
picture->mState = AttachedPicture::ChangeState::Saved;
++iter;
}
}
}
bool MP3Metadata::WriteMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
auto stream = new TagLib::FileStream(reinterpret_cast<const char *>(buf));
TagLib::MPEG::File file(stream, TagLib::ID3v2::FrameFactory::instance(), false);
if(!file.isValid()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MPEG file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Not an MPEG file"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
// APE and ID3v1 tags are only written if present, but ID3v2 tags are always written
auto APETag = file.APETag();
if(APETag && !APETag->isEmpty())
SetAPETagFromMetadata(*this, APETag);
auto ID3v1Tag = file.ID3v1Tag();
if(ID3v1Tag && !ID3v1Tag->isEmpty())
SetID3v1TagFromMetadata(*this, ID3v1Tag);
SetID3v2TagFromMetadata(*this, file.ID3v2Tag(true));
if(!file.save()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MPEG file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Unable to write metadata"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
MergeChangedMetadataIntoMetadata();
return true;
}
bool MonkeysAudioMetadata::WriteMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
auto stream = new TagLib::FileStream(reinterpret_cast<const char *>(buf));
TagLib::APE::File file(stream, false);
if(!file.isValid()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Monkey's Audio file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Not a Monkey's Audio file"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
// Although both ID3v1 and APE tags are read, only APE tags are written
if(file.APETag())
SetAPETagFromMetadata(*this, file.APETag());
if(!file.save()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Monkey's Audio file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Unable to write metadata"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
MergeChangedMetadataIntoMetadata();
return true;
}
bool OggVorbisMetadata::WriteMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
auto stream = new TagLib::FileStream(reinterpret_cast<const char *>(buf));
TagLib::Ogg::Vorbis::File file(stream, false);
if(!file.isValid()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Ogg Vorbis file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Not an Ogg Vorbis file"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
SetXiphCommentFromMetadata(*this, file.tag());
if(!file.save()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Ogg Vorbis file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Unable to write metadata"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
MergeChangedMetadataIntoMetadata();
return true;
}
bool TrueAudioMetadata::WriteMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
// TODO: Use unique_ptr once the switch to C++11 STL is made
std::auto_ptr<TagLib::FileStream> stream(new TagLib::FileStream(reinterpret_cast<const char *>(buf)));
if(!stream->isOpen()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” could not be opened for writing."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Input/output error"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file may have been renamed, moved, deleted, or you may not have appropriate permissions."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
TagLib::TrueAudio::File file(stream.get(), false);
if(!file.isValid()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid True Audio file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Not a True Audio file"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
// ID3v1 tags are only written if present, but ID3v2 tags are always written
if(file.ID3v1Tag())
SetID3v1TagFromMetadata(*this, file.ID3v1Tag());
SetID3v2TagFromMetadata(*this, file.ID3v2Tag(true));
if(!file.save()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid True Audio file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Unable to write metadata"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
MergeChangedMetadataIntoMetadata();
return true;
}
bool MonkeysAudioMetadata::WriteMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
TagLib::IOStream *stream = new TagLib::FileStream(reinterpret_cast<const char *>(buf));
TagLib::APE::File file(stream, false);
if(!file.isValid()) {
if(error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Mpnkey's Audio file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not a Mpnkey's Audio file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataInputOutputError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
return false;
}
// Although both ID3v1 and APE tags are read, only APE tags are written
if(file.APETag())
SetAPETagFromMetadata(*this, file.APETag());
if(!file.save()) {
if(error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid Mpnkey's Audio file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Unable to write metadata"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataInputOutputError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
return false;
}
MergeChangedMetadataIntoMetadata();
return true;
}
bool FLACMetadata::WriteMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
auto stream = new TagLib::FileStream(reinterpret_cast<const char *>(buf));
TagLib::FLAC::File file(stream, TagLib::ID3v2::FrameFactory::instance(), false);
if(!file.isValid()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid FLAC file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Not a FLAC file"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
SetXiphCommentFromMetadata(*this, file.xiphComment(), false);
// Remove existing cover art
file.removePictures();
// Add album art
for(auto attachedPicture : GetAttachedPictures()) {
CGImageSourceRef imageSource = CGImageSourceCreateWithData(attachedPicture->GetData(), nullptr);
if(nullptr == imageSource) {
LOGGER_ERR("org.sbooth.AudioEngine.AudioMetadata.FLAC", "Skipping album art (unable to create image)");
continue;
}
TagLib::FLAC::Picture *picture = new TagLib::FLAC::Picture;
picture->setData(TagLib::ByteVector((const char *)CFDataGetBytePtr(attachedPicture->GetData()), (TagLib::uint)CFDataGetLength(attachedPicture->GetData())));
picture->setType(static_cast<TagLib::FLAC::Picture::Type>(attachedPicture->GetType()));
if(attachedPicture->GetDescription())
picture->setDescription(TagLib::StringFromCFString(attachedPicture->GetDescription()));
// Convert the image's UTI into a MIME type
CFStringRef mimeType = UTTypeCopyPreferredTagWithClass(CGImageSourceGetType(imageSource), kUTTagClassMIMEType);
if(mimeType) {
picture->setMimeType(TagLib::StringFromCFString(mimeType));
CFRelease(mimeType), mimeType = nullptr;
}
// Flesh out the height, width, and depth
CFDictionaryRef imagePropertiesDictionary = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nullptr);
if(imagePropertiesDictionary) {
CFNumberRef imageWidth = (CFNumberRef)CFDictionaryGetValue(imagePropertiesDictionary, kCGImagePropertyPixelWidth);
CFNumberRef imageHeight = (CFNumberRef)CFDictionaryGetValue(imagePropertiesDictionary, kCGImagePropertyPixelHeight);
CFNumberRef imageDepth = (CFNumberRef)CFDictionaryGetValue(imagePropertiesDictionary, kCGImagePropertyDepth);
int height, width, depth;
// Ignore numeric conversion errors
CFNumberGetValue(imageWidth, kCFNumberIntType, &width);
CFNumberGetValue(imageHeight, kCFNumberIntType, &height);
CFNumberGetValue(imageDepth, kCFNumberIntType, &depth);
picture->setHeight(height);
picture->setWidth(width);
picture->setColorDepth(depth);
CFRelease(imagePropertiesDictionary), imagePropertiesDictionary = nullptr;
}
file.addPicture(picture);
CFRelease(imageSource), imageSource = nullptr;
}
if(!file.save()) {
if(error) {
CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid FLAC file."), "");
CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Unable to write metadata"), "");
CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), "");
*error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion);
CFRelease(description), description = nullptr;
CFRelease(failureReason), failureReason = nullptr;
CFRelease(recoverySuggestion), recoverySuggestion = nullptr;
}
return false;
}
MergeChangedMetadataIntoMetadata();
return true;
}
bool FLACMetadata::WriteMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
FLAC__Metadata_Chain *chain = FLAC__metadata_chain_new();
// ENOMEM sux
if(NULL == chain)
return false;
if(!FLAC__metadata_chain_read(chain, reinterpret_cast<const char *>(buf))) {
// Attempt to provide a descriptive error message
if(NULL != error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
switch(FLAC__metadata_chain_status(chain)) {
case FLAC__METADATA_CHAIN_STATUS_NOT_A_FLAC_FILE:
{
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid FLAC file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not a FLAC file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
break;
}
case FLAC__METADATA_CHAIN_STATUS_BAD_METADATA:
{
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid FLAC file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not a FLAC file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file contains bad metadata."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
break;
}
default:
{
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid FLAC file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not a FLAC file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
break;
}
}
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataFileFormatNotRecognizedError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
FLAC__metadata_chain_delete(chain), chain = NULL;
return false;
}
FLAC__metadata_chain_sort_padding(chain);
FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
if(NULL == iterator) {
FLAC__metadata_chain_delete(chain), chain = NULL;
return false;
}
FLAC__metadata_iterator_init(iterator, chain);
// Seek to the vorbis comment block if it exists
while(FLAC__METADATA_TYPE_VORBIS_COMMENT != FLAC__metadata_iterator_get_block_type(iterator)) {
if(!FLAC__metadata_iterator_next(iterator))
break; // Already at end
}
FLAC__StreamMetadata *block = NULL;
// If there isn't a vorbis comment block add one
if(FLAC__METADATA_TYPE_VORBIS_COMMENT != FLAC__metadata_iterator_get_block_type(iterator)) {
// The padding block will be the last block if it exists; add the comment block before it
if(FLAC__METADATA_TYPE_PADDING == FLAC__metadata_iterator_get_block_type(iterator))
FLAC__metadata_iterator_prev(iterator);
block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
if(NULL == block) {
FLAC__metadata_chain_delete(chain), chain = NULL;
FLAC__metadata_iterator_delete(iterator), iterator = NULL;
return false;
}
// Add our metadata
if(!FLAC__metadata_iterator_insert_block_after(iterator, block)) {
if(NULL != error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid FLAC file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Unable to write metadata"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataInputOutputError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
FLAC__metadata_chain_delete(chain), chain = NULL;
FLAC__metadata_iterator_delete(iterator), iterator = NULL;
return false;
}
}
else
block = FLAC__metadata_iterator_get_block(iterator);
// Standard tags
SetVorbisComment(block, "ALBUM", GetAlbumTitle());
SetVorbisComment(block, "ARTIST", GetArtist());
SetVorbisComment(block, "ALBUMARTIST", GetAlbumArtist());
SetVorbisComment(block, "COMPOSER", GetComposer());
SetVorbisComment(block, "GENRE", GetGenre());
SetVorbisComment(block, "DATE", GetReleaseDate());
SetVorbisComment(block, "DESCRIPTION", GetComment());
SetVorbisComment(block, "TITLE", GetTitle());
SetVorbisCommentNumber(block, "TRACKNUMBER", GetTrackNumber());
SetVorbisCommentNumber(block, "TRACKTOTAL", GetTrackTotal());
SetVorbisCommentBoolean(block, "COMPILATION", GetCompilation());
SetVorbisCommentNumber(block, "DISCNUMBER", GetDiscNumber());
SetVorbisCommentNumber(block, "DISCTOTAL", GetDiscTotal());
SetVorbisComment(block, "ISRC", GetISRC());
SetVorbisComment(block, "MCN", GetMCN());
// Additional metadata
CFDictionaryRef additionalMetadata = GetAdditionalMetadata();
if(NULL != additionalMetadata) {
CFIndex count = CFDictionaryGetCount(additionalMetadata);
const void * keys [count];
const void * values [count];
CFDictionaryGetKeysAndValues(additionalMetadata,
reinterpret_cast<const void **>(keys),
reinterpret_cast<const void **>(values));
for(CFIndex i = 0; i < count; ++i) {
CFIndex keySize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(reinterpret_cast<CFStringRef>(keys[i])), kCFStringEncodingASCII);
char key [keySize + 1];
if(!CFStringGetCString(reinterpret_cast<CFStringRef>(keys[i]), key, keySize + 1, kCFStringEncodingASCII)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.FLAC");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
continue;
}
SetVorbisComment(block, key, reinterpret_cast<CFStringRef>(values[i]));
}
}
// ReplayGain info
SetVorbisCommentDouble(block, "REPLAYGAIN_REFERENCE_LOUDNESS", GetReplayGainReferenceLoudness(), CFSTR("%2.1f dB"));
SetVorbisCommentDouble(block, "REPLAYGAIN_TRACK_GAIN", GetReplayGainReferenceLoudness(), CFSTR("%+2.2f dB"));
SetVorbisCommentDouble(block, "REPLAYGAIN_TRACK_PEAK", GetReplayGainTrackGain(), CFSTR("%1.8f"));
SetVorbisCommentDouble(block, "REPLAYGAIN_ALBUM_GAIN", GetReplayGainAlbumGain(), CFSTR("%+2.2f dB"));
SetVorbisCommentDouble(block, "REPLAYGAIN_ALBUM_PEAK", GetReplayGainAlbumPeak(), CFSTR("%1.8f"));
// Write the new metadata to the file
if(!FLAC__metadata_chain_write(chain, true, false)) {
if(NULL != error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid FLAC file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Unable to write metadata"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataInputOutputError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
FLAC__metadata_chain_delete(chain), chain = NULL;
FLAC__metadata_iterator_delete(iterator), iterator = NULL;
return false;
}
FLAC__metadata_chain_delete(chain), chain = NULL;
FLAC__metadata_iterator_delete(iterator), iterator = NULL;
MergeChangedMetadataIntoMetadata();
return true;
}
bool MP4Metadata::WriteMetadata(CFErrorRef *error)
{
UInt8 buf [PATH_MAX];
if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX))
return false;
// Open the file for modification
MP4FileHandle file = MP4Modify(reinterpret_cast<const char *>(buf));
if(MP4_INVALID_FILE_HANDLE == file) {
if(error) {
CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault,
32,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef displayName = CreateDisplayNameForURL(mURL);
CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault,
NULL,
CFCopyLocalizedString(CFSTR("The file “%@” is not a valid MPEG-4 file."), ""),
displayName);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedDescriptionKey,
errorString);
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedFailureReasonKey,
CFCopyLocalizedString(CFSTR("Not an MPEG file"), ""));
CFDictionarySetValue(errorDictionary,
kCFErrorLocalizedRecoverySuggestionKey,
CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""));
CFRelease(errorString), errorString = NULL;
CFRelease(displayName), displayName = NULL;
*error = CFErrorCreate(kCFAllocatorDefault,
AudioMetadataErrorDomain,
AudioMetadataInputOutputError,
errorDictionary);
CFRelease(errorDictionary), errorDictionary = NULL;
}
return false;
}
// Read the tags
const MP4Tags *tags = MP4TagsAlloc();
if(NULL == tags) {
MP4Close(file), file = NULL;
if(error)
*error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, ENOMEM, NULL);
return false;
}
MP4TagsFetch(tags, file);
// Album Title
CFStringRef str = GetAlbumTitle();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetAlbum(tags, cString);
}
else
MP4TagsSetAlbum(tags, NULL);
// Artist
str = GetArtist();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetArtist(tags, cString);
}
else
MP4TagsSetArtist(tags, NULL);
// Album Artist
str = GetAlbumArtist();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetAlbumArtist(tags, cString);
}
else
MP4TagsSetAlbumArtist(tags, NULL);
// Genre
str = GetGenre();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetGenre(tags, cString);
}
else
MP4TagsSetGenre(tags, NULL);
// Release date
str = GetReleaseDate();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetReleaseDate(tags, cString);
}
else
MP4TagsSetReleaseDate(tags, NULL);
// Composer
str = GetComposer();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetComposer(tags, cString);
}
else
MP4TagsSetComposer(tags, NULL);
// Comment
str = GetComment();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetComments(tags, cString);
}
else
MP4TagsSetComments(tags, NULL);
// Track title
str = GetTitle();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetName(tags, cString);
}
else
MP4TagsSetName(tags, NULL);
// Track number and total
MP4TagTrack trackInfo;
memset(&trackInfo, 0, sizeof(MP4TagTrack));
if(GetTrackNumber())
CFNumberGetValue(GetTrackNumber(), kCFNumberSInt32Type, &trackInfo.index);
if(GetTrackTotal())
CFNumberGetValue(GetTrackTotal(), kCFNumberSInt32Type, &trackInfo.total);
MP4TagsSetTrack(tags, &trackInfo);
// Disc number and total
MP4TagDisk discInfo;
memset(&discInfo, 0, sizeof(MP4TagDisk));
if(GetDiscNumber())
CFNumberGetValue(GetDiscNumber(), kCFNumberSInt32Type, &discInfo.index);
if(GetDiscTotal())
CFNumberGetValue(GetDiscTotal(), kCFNumberSInt32Type, &discInfo.total);
MP4TagsSetDisk(tags, &discInfo);
// Compilation
if(GetCompilation()) {
uint8_t comp = CFBooleanGetValue(GetCompilation());
MP4TagsSetCompilation(tags, &comp);
}
else
MP4TagsSetCompilation(tags, NULL);
// Lyrics
str = GetLyrics();
if(str) {
CFIndex cStringSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str), kCFStringEncodingUTF8);
char cString [cStringSize + 1];
if(!CFStringGetCString(str, cString, cStringSize + 1, kCFStringEncodingUTF8)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
MP4TagsSetLyrics(tags, cString);
}
else
MP4TagsSetLyrics(tags, NULL);
// Album art
CFDataRef artData = GetFrontCoverArt();
if(artData) {
MP4TagArtwork artwork;
artwork.data = reinterpret_cast<void *>(const_cast<UInt8 *>(CFDataGetBytePtr(artData)));
artwork.size = static_cast<uint32_t>(CFDataGetLength(artData));
artwork.type = MP4_ART_UNDEFINED;
MP4TagsAddArtwork(tags, &artwork);
}
// Save our changes
MP4TagsStore(tags, file);
// Replay Gain
// Reference loudness
if(GetReplayGainReferenceLoudness()) {
float f;
if(!CFNumberGetValue(GetReplayGainReferenceLoudness(), kCFNumberFloatType, &f)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFStringGetCString() failed");
return false;
}
char value [8];
snprintf(value, sizeof(value), "%2.1f dB", f);
MP4ItmfItem *item = MP4ItmfItemAlloc("----", 1);
if(NULL != item) {
item->mean = strdup("com.apple.iTunes");
item->name = strdup("replaygain_reference_loudness");
item->dataList.elements[0].typeCode = MP4_ITMF_BT_UTF8;
item->dataList.elements[0].value = reinterpret_cast<uint8_t *>(strdup(value));
item->dataList.elements[0].valueSize = static_cast<uint32_t>(strlen(value));
}
}
else {
MP4ItmfItemList *items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_reference_loudness");
if(items) {
for(uint32_t i = 0; i < items->size; ++i)
MP4ItmfRemoveItem(file, items->elements + i);
}
MP4ItmfItemListFree(items), items = NULL;
}
// Track gain
if(GetReplayGainTrackGain()) {
float f;
if(!CFNumberGetValue(GetReplayGainTrackGain(), kCFNumberFloatType, &f)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFNumberGetValue() failed");
return false;
}
char value [10];
snprintf(value, sizeof(value), "%+2.2f dB", f);
MP4ItmfItem *item = MP4ItmfItemAlloc("----", 1);
if(NULL != item) {
item->mean = strdup("com.apple.iTunes");
item->name = strdup("replaygain_track_gain");
item->dataList.elements[0].typeCode = MP4_ITMF_BT_UTF8;
item->dataList.elements[0].value = reinterpret_cast<uint8_t *>(strdup(value));
item->dataList.elements[0].valueSize = static_cast<uint32_t>(strlen(value));
}
}
else {
MP4ItmfItemList *items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_track_gain");
if(items) {
for(uint32_t i = 0; i < items->size; ++i)
MP4ItmfRemoveItem(file, items->elements + i);
}
MP4ItmfItemListFree(items), items = NULL;
}
// Track peak
if(GetReplayGainTrackPeak()) {
float f;
if(!CFNumberGetValue(GetReplayGainTrackPeak(), kCFNumberFloatType, &f)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFNumberGetValue() failed");
return false;
}
char value [12];
snprintf(value, sizeof(value), "%1.8f", f);
MP4ItmfItem *item = MP4ItmfItemAlloc("----", 1);
if(NULL != item) {
item->mean = strdup("com.apple.iTunes");
item->name = strdup("replaygain_track_peak");
item->dataList.elements[0].typeCode = MP4_ITMF_BT_UTF8;
item->dataList.elements[0].value = reinterpret_cast<uint8_t *>(strdup(value));
item->dataList.elements[0].valueSize = static_cast<uint32_t>(strlen(value));
}
}
else {
MP4ItmfItemList *items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_track_peak");
if(items) {
for(uint32_t i = 0; i < items->size; ++i)
MP4ItmfRemoveItem(file, items->elements + i);
}
MP4ItmfItemListFree(items), items = NULL;
}
// Album gain
if(GetReplayGainAlbumGain()) {
float f;
if(!CFNumberGetValue(GetReplayGainAlbumGain(), kCFNumberFloatType, &f)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFNumberGetValue() failed");
return false;
}
char value [10];
snprintf(value, sizeof(value), "%+2.2f dB", f);
MP4ItmfItem *item = MP4ItmfItemAlloc("----", 1);
if(NULL != item) {
item->mean = strdup("com.apple.iTunes");
item->name = strdup("replaygain_album_gain");
item->dataList.elements[0].typeCode = MP4_ITMF_BT_UTF8;
item->dataList.elements[0].value = reinterpret_cast<uint8_t *>(strdup(value));
item->dataList.elements[0].valueSize = static_cast<uint32_t>(strlen(value));
}
}
else {
MP4ItmfItemList *items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_album_gain");
if(items) {
for(uint32_t i = 0; i < items->size; ++i)
MP4ItmfRemoveItem(file, items->elements + i);
}
MP4ItmfItemListFree(items), items = NULL;
}
// Album peak
if(GetReplayGainAlbumPeak()) {
float f;
if(!CFNumberGetValue(GetReplayGainAlbumPeak(), kCFNumberFloatType, &f)) {
log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine.AudioMetadata.MP4");
LOG4CXX_WARN(logger, "CFNumberGetValue() failed");
return false;
}
char value [12];
snprintf(value, sizeof(value), "%1.8f", f);
MP4ItmfItem *item = MP4ItmfItemAlloc("----", 1);
if(NULL != item) {
item->mean = strdup("com.apple.iTunes");
item->name = strdup("replaygain_album_peak");
item->dataList.elements[0].typeCode = MP4_ITMF_BT_UTF8;
item->dataList.elements[0].value = reinterpret_cast<uint8_t *>(strdup(value));
item->dataList.elements[0].valueSize = static_cast<uint32_t>(strlen(value));
}
}
else {
MP4ItmfItemList *items = MP4ItmfGetItemsByMeaning(file, "com.apple.iTunes", "replaygain_album_peak");
if(items) {
for(uint32_t i = 0; i < items->size; ++i)
MP4ItmfRemoveItem(file, items->elements + i);
}
MP4ItmfItemListFree(items), items = NULL;
}
// Clean up
MP4TagsFree(tags), tags = NULL;
MP4Close(file), file = NULL;
MergeChangedMetadataIntoMetadata();
return true;
}
