public byte[] ReadImageResource(string imageGroupId, MediaImageSize imageSize, out string imageType)
{
imageType = string.Empty;
Guid imageGroupGuid;
if (!Guid.TryParse(imageGroupId, out imageGroupGuid))
{
return(null);
}
var mediaImage = (from mi in _mediaDataContext.Get <MediaImage>()
where mi.ImageGroup.Id == imageGroupGuid &&
mi.ImageSize == imageSize && mi.IsArchived == false
select new { Format = mi.Format, Url = mi.Url })
.FirstOrDefault();
if (mediaImage == null || string.IsNullOrEmpty(mediaImage.Url))
{
return(null);
}
byte[] imageData = null;
imageType = MediaFormatExtension.GetMimeType(mediaImage.Format);
using (var stream = _storage.Open(mediaImage.Url))
{
imageData = new byte[stream.Length];
if (stream.Read(imageData, 0, imageData.Length) != imageData.Length)
{
imageData = null;
}
}
return(imageData);
}
private void SyncMediaFileStream(MediaFile mediaFile, string copyAsFilePath, string encoderFilePath)
{
var fileStates = new MediaFileStateInfos
{
MediaFileStateJson = string.Empty,
EncoderFileStateJson = string.Empty
};
using (var file = _localStorage.Open(mediaFile.TempUrl))
{
// Generate encoder state and store as json file.
if (!string.IsNullOrEmpty(encoderFilePath))
{
var encoderStateJson = MediaEncoderExtension.GenerateEncoderState(mediaFile.Format, file, true);
if (!string.IsNullOrEmpty(encoderStateJson))
{
using (var mem = new MemoryStream(ASCIIEncoding.UTF8.GetBytes(encoderStateJson)))
{
using (var encoderFile = _mediaStorage.StoreAndGetFileStream(encoderFilePath, mem, "text/json"))
{
fileStates.EncoderFileStateJson = encoderFile.SaveStateAsJson();
}
}
}
}
using (var mediaFileStream = _mediaStorage.StoreAndGetFileStream(copyAsFilePath, file,
MediaFormatExtension.GetMimeType(mediaFile.Format)))
{
fileStates.MediaFileStateJson = mediaFileStream.SaveStateAsJson();
}
}
// Add MediaFileStateInfo entry.
_mediaDataContext.Add(new MediaFileStateInfo
{
MediaFileId = mediaFile.Id,
StateInfoJson = JsonConvert.SerializeObject(fileStates)
});
}
public bool UploadMedia(Stream media, string fileName, Guid userId, string mediaFormat = MediaFormatExtension.AudioMp3)
{
// Get latest not synced upload by the user or create new media upload entry.
Guid mediaUploadId = (from mu in _mediaDataContext.Get <MediaUpload>()
where mu.UserId == userId && mu.IsSynced == false
select mu.Id).FirstOrDefault();
// Create media upload entry.
if (mediaUploadId == Guid.Empty)
{
mediaUploadId = Guid.NewGuid();
_mediaDataContext.Add(new MediaUpload()
{
Id = mediaUploadId,
UserId = userId
});
_mediaDataContext.SaveChanges();
}
// Copy media file under media upload entry.
string mediaPath = $"{mediaUploadId}{DirDelimiter}{fileName}";
if (!_localStorage.Store(mediaPath, media, MediaFormatExtension.GetMimeType(mediaFormat)))
{
return(false);
}
// Read metadata from media file and serialize into json.
var metadataJson = string.Empty;
using (var mediaFile = _localStorage.Open(mediaPath))
{
IEnumerable <AttachedPicture> pictures;
var metadata = mediaFile.ReadMetadata(mediaFormat, out pictures);
// Create attached picture files.
if (pictures != null && pictures.Any())
{
metadata.AlbumImagesUrl = new Dictionary <AttachedPictureType, string>();
foreach (var pic in pictures)
{
string filePath = $"{mediaUploadId}{DirDelimiter}artwork{DirDelimiter}{fileName}-{pic.Type}.jpeg";
using (var pictureStream = new MemoryStream(pic.PictureData, false))
{
if (_localStorage.Store(filePath, pictureStream, MediaFormatExtension.GetMimeType(mediaFormat)))
{
if (pic.Type == AttachedPictureType.Artist || pic.Type == AttachedPictureType.Band)
{
metadata.ArtistImageUrl = filePath;
}
else
{
metadata.AlbumImagesUrl.Add(pic.Type, filePath);
}
}
}
}
}
if (metadata != null)
{
metadataJson = Newtonsoft.Json.JsonConvert.SerializeObject(metadata);
}
}
// Create entry in media table using mediaupload id.
_mediaDataContext.Add(new MediaFile()
{
Id = Guid.NewGuid(),
MediaUploadId = mediaUploadId,
UserId = userId,
Format = mediaFormat,
MediaInfoJson = metadataJson,
TempUrl = mediaPath,
FileSize = media.Length,
});
// var mediaUpload = _mediaDataContext.Get<MediaUpload>().Where(x => x.Id == mediaUploadId).FirstOrDefault();
// mediaUpload.NumOfMedia++;
//_mediaDataContext.Update(mediaUpload);
_mediaDataContext.Update <MediaUpload>(x => x.Id == mediaUploadId, x => x.NumOfMedia++);
_mediaDataContext.SaveChanges();
return(true);
}
protected void CreateMediaWithRelationships(IMediaMetadata meta, Guid mediaId, Guid userId, string imageSavePath, bool saveChanges)
{
Guid artistCoverMediaId = Guid.Parse("00000000-0000-0000-0000-000000000001");
Guid albumCoverMediaId = Guid.Parse("00000000-0000-0000-0000-000000000002");
// Create/Update Genre.
string genreName = meta.Genre;
if (string.IsNullOrEmpty(genreName))
{
genreName = "Unknown";
}
var genre = _mediaDataContext.Get <Genre>().Where(x => x.Name == genreName).FirstOrDefault();
if (genre == null)
{
genre = new Genre
{
Id = Guid.NewGuid(),
Name = genreName
};
_mediaDataContext.Add(genre);
}
// Create/Update Artist.
string artistName = meta.Artist;
if (string.IsNullOrEmpty(artistName))
{
artistName = "Unknown Artist";
}
var artist = _mediaDataContext.Get <Artist>().Where(x => x.Name == artistName).FirstOrDefault();
if (artist == null)
{
artist = new Artist
{
Id = Guid.NewGuid(),
Name = artistName,
GenreId = genre.Id,
Genre = genre
};
_mediaDataContext.Add(artist);
}
// Create/Update Album.
string albumName = meta.Album;
if (string.IsNullOrEmpty(albumName))
{
albumName = "Unknown Album";
}
var album = _mediaDataContext.Get <Album>().Where(x => x.Name == albumName).FirstOrDefault();
if (album == null)
{
int year = 0;
int.TryParse(meta.Year, out year);
album = new Album
{
Id = Guid.NewGuid(),
Name = albumName,
ArtistId = artist.Id,
Year = year,
};
// Album cover image.
if (meta.AlbumImagesUrl != null && meta.AlbumImagesUrl.Any())
{
string albumImageUrl = meta.AlbumImagesUrl.FirstOrDefault().Value;
IEnumerable <MediaImage> images = null;
using (var imageStream = _localStorage.Open(albumImageUrl))
{
images = ResizeAndCopyImage(imageStream, imageSavePath, "album", MediaFormatExtension.GetMimeType(MediaFormatExtension.ImageJpeg));
}
if (images != null && images.Any())
{
var imageGroup = new MediaImageGroup
{
UserId = userId
};
_mediaDataContext.Add(imageGroup);
_mediaDataContext.Add(new AlbumAndMediaImage
{
AlbumId = album.Id,
IsCoverImage = true,
MediaImageGroupId = imageGroup.Id
});
foreach (var m in images)
{
m.ImageGroupId = imageGroup.Id;
_mediaDataContext.Add(m);
}
}
}
_mediaDataContext.Add(album);
}
// Create/Update Song.
string songName = meta.Song;
if (string.IsNullOrEmpty(songName))
{
albumName = "Unknown Song";
}
int trackNumber = 0;
int.TryParse(meta.Track, out trackNumber);
var song = new Song
{
Id = Guid.NewGuid(),
Name = songName,
AlbumId = album.Id,
TrackNumber = trackNumber,
DurationSec = meta.DurationSec,
MediaId = mediaId
};
_mediaDataContext.Add(song);
if (saveChanges)
{
_mediaDataContext.SaveChanges();
}
}
public void Add(MediaFormatExtension mediaFormat, IFileFormatParser fileFormatParser)
{
fileFormatParserCollection.Add(mediaFormat, fileFormatParser);
}
