public async Task <IActionResult> Delete(int id)
{
try
{
BaseMedia media = await _Db.Media.FindAsync(id);
if (media == null)
{
return(NotFound("The requested media file does not exist."));
}
// Todo: Check whether the media file is being used in the website or app
// and prevent deletion if so.
Dictionary <string, HashSet <string> > usages = media.GetUsages(_Db);
// If the usages dictionary has keys, file is used
if (usages.Count > 0)
{
return(BadRequest(new ResponseHelper("This file cannot be deleted as it is in use. Remove usages and try again.")));
}
// Otherwise, we can go ahead and delete
if (media is ImageMedia)
{
// Delete the directory containing image versions
string dirPath = Path.Combine("Storage", "Media", "Images", Path.GetFileNameWithoutExtension(media.Filename));
try
{
Directory.Delete(dirPath, recursive: true);
}
catch (DirectoryNotFoundException)
{
_Logger.LogWarning("While deleting image {0}: Version directory not found. Continuing.", id);
}
}
// Finally, delete the media file itself
System.IO.File.Delete(media.FilePath);
// And remove its record in the database
_Db.Remove(media);
await _Db.SaveChangesAsync();
_Logger.LogDebug("Media file {0} deleted", id);
return(Ok());
}
catch (Exception ex)
{
_Logger.LogError("Error deleting media file {0}: {1}", id, ex.Message);
_Logger.LogError(ex.StackTrace);
return(BadRequest("Something went wrong, please try again later."));
}
}
public async Task <IActionResult> Crop(int id, CropData args)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid arguments provided to crop image."));
}
BaseMedia media = await _Db.Media.FindAsync(id);
if (media == null)
{
return(NotFound("The requested media file does not exist."));
}
ImageMedia oldImage = media as ImageMedia;
if (oldImage == null)
{
return(BadRequest("Unable to crop non-image media file."));
}
// Generate new GUID
string filename = Guid.NewGuid().ToString() + Path.GetExtension(oldImage.Filename);
// Save the file again, passing in crop data
ImageUtils.SaveImage(await System.IO.File.ReadAllBytesAsync(oldImage.FilePath), Path.Combine("Storage", "Media", "Images", filename), args);
ImageMedia newImage = new ImageMedia
{
Title = oldImage.Title,
Alt = oldImage.Alt,
Name = oldImage.Name + "_cropped",
// other values provided by cropping code
};
await _Db.AddAsync(newImage);
await _Db.SaveChangesAsync();
_Logger.LogDebug("Media file {0} cropped - new file ID is {1}", id, newImage.Id);
return(Ok(newImage.Id)); // Todo: may want to pass back something else here
}
catch (Exception ex)
{
_Logger.LogError("Error cropping media file {0}: {1}", id, ex.Message);
_Logger.LogError(ex.StackTrace);
return(BadRequest("Something went wrong, please try again later."));
}
}
public async Task <IActionResult> Index(string filename, int width = 0, bool original = false, bool download = false)
{
try
{
if (string.IsNullOrEmpty(filename))
{
return(NotFound("No filename provided"));
}
BaseMedia file = await _Db.Media
.Where(m => m.Filename == filename)
.FirstOrDefaultAsync();
if (file == null)
{
return(NotFound("No file exists for the supplied filename"));
}
// If a download is requested, set the mandatory header.
if (download)
{
Response.Headers.Add(file.DownloadHeader());
}
// Return file if not image
if (file.GetCategory() != MediaCategory.Image)
{
//return new EmptyResult();
return(File(await System.IO.File.ReadAllBytesAsync(file.FilePath), file.MediaType.Mime));
}
else
{
ImageMedia imageFile = (ImageMedia)file;
// Return the appropriate image
//return new EmptyResult();
return(File(await System.IO.File.ReadAllBytesAsync(imageFile.GetImagePath(width, original)), imageFile.MediaType.Mime));
}
}
catch (Exception ex)
{
_Logger.LogError("Error retrieving file: {0}", ex.Message);
_Logger.LogError(ex.StackTrace);
return(BadRequest("Something went wrong, please try again later."));
}
}
public async Task <IActionResult> GetOne(int id)
{
try
{
BaseMedia mediaFile = await _Db.Media.FindAsync(id);
ImageMedia imageFile = mediaFile as ImageMedia;
AudioMedia audioFile = mediaFile as AudioMedia;
if (mediaFile == null)
{
return(NotFound("No file exists for the supplied ID"));
}
return(Ok(new
{
mediaFile.Id,
mediaFile.Name,
mediaFile.FilePath,
mediaFile.Size,
mediaFile.MediaType,
Source = new {
showCopyright = mediaFile.ShowCopyright,
info = mediaFile.Source
},
fileName = mediaFile.Filename,
height = imageFile?.Height,
width = imageFile?.Width,
versions = imageFile?.Versions,
title = imageFile?.Title,
alt = imageFile?.Alt,
duration = audioFile?.Duration,
tags = mediaFile.Tags(),
usages = mediaFile.GetUsages(_Db)
}));
}
catch (Exception ex)
{
_Logger.LogError("Error retrieving file data: {0}", ex.Message);
_Logger.LogError(ex.StackTrace);
return(BadRequest("Something went wrong, please try again later."));
}
}
public async Task <IActionResult> Update(int id, IFormCollection request)
{
try
{
BaseMedia media = await _Db.Media.FindAsync(id);
if (media == null)
{
return(NotFound("The requested media file does not exist."));
}
// All types of media have a name, so we can update that
media.Name = request.Str("name");
media.Source = request.Str("source");
media.ShowCopyright = request.Bool("showCopyright");
// If file is an image, we can also set the title and alt-text
if (media is ImageMedia)
{
(media as ImageMedia).Title = request.Str("title");
(media as ImageMedia).Alt = request.Str("alt");
}
// Save changes
await _Db.SaveChangesAsync();
_Logger.LogDebug("Metadata updated for media file {0}", id);
return(Ok());
}
catch (Exception ex)
{
_Logger.LogError("Error updating metadata for media file {0}: {1}", id, ex.Message);
_Logger.LogError(ex.StackTrace);
return(BadRequest("Something went wrong, please try again later."));
}
}
public BaseMedia CreateEmptyMP4(Mp4Metadata videoData)
{
var test = new BaseMedia();
{// File type
var ftyp = new MatrixIO.IO.Bmff.Boxes.FileTypeBox();
ftyp.CompatibleBrands.Add("isom");
ftyp.CompatibleBrands.Add("iso2");
ftyp.CompatibleBrands.Add("avc1");
ftyp.CompatibleBrands.Add("iso6");
ftyp.CompatibleBrands.Add("mp41");
ftyp.MajorBrand = "isom";
ftyp.MinorVersion = 512;
test.Children.Add(ftyp);
}
{ // Movie
var moov = new MatrixIO.IO.Bmff.Boxes.MovieBox();
{ // Movie header
var mvhd = new MatrixIO.IO.Bmff.Boxes.MovieHeaderBox();
// Leave all default, except stuff from ffmpeg that isn't the same
mvhd.TimeScale = 1000;
mvhd.NextTrackID = 2;
moov.Children.Add(mvhd);
}
{ // Track
var trak = new MatrixIO.IO.Bmff.Boxes.TrackBox();
{ // Track header
var tkhd = new MatrixIO.IO.Bmff.Boxes.TrackHeaderBox();
tkhd.Width = MatrixIO.IO.Numerics.FixedPoint_16_16.FromDouble(videoData.Dimensions.Width);
tkhd.Height = MatrixIO.IO.Numerics.FixedPoint_16_16.FromDouble(videoData.Dimensions.Height);
tkhd.Enabled = true;
tkhd.InMovie = true;
tkhd.TrackID = 1;
trak.Children.Add(tkhd);
}
{ // Media
var mdia = new MatrixIO.IO.Bmff.Boxes.MediaBox();
{ // Media header
var mdhd = new MatrixIO.IO.Bmff.Boxes.MediaHeaderBox();
mdhd.TimeScale = 10240;
mdia.Children.Add(mdhd);
}
{// Handler
var hdlr = new MatrixIO.IO.Bmff.Boxes.HandlerBox();
hdlr.HandlerType = HDLR.TYPE_VIDEO;
hdlr.Name = HDLR.NAME_VIDEO;
mdia.Children.Add(hdlr);
}
{ // Media information
var minf = new MatrixIO.IO.Bmff.Boxes.MediaInformationBox();
{ // Video media header
var vmhd = new MatrixIO.IO.Bmff.Boxes.VideoMediaHeaderBox();
vmhd.NoLeanAhead = true;
minf.Children.Add(vmhd);
}
{ // Data Information
var dinf = new MatrixIO.IO.Bmff.Boxes.DataInformationBox();
{ // Data reference
var dref = new MatrixIO.IO.Bmff.Boxes.DataReferenceBox();
{ // URL
var url = new MatrixIO.IO.Bmff.Boxes.DataEntryUrlBox();
url.MovieIsSelfContained = true;
dref.Children.Add(url);
}
dinf.Children.Add(dref);
}
minf.Children.Add(dinf);
}
{ // Sample table
var stbl = new MatrixIO.IO.Bmff.Boxes.SampleTableBox();
{ // Sample description
var stsd = new MatrixIO.IO.Bmff.Boxes.SampleDescriptionBox();
{ // Avc1
var avc1 = new Avc1();
avc1.VideoWidth = (UInt16)videoData.Dimensions.Width;
avc1.VideoHeight = (UInt16)videoData.Dimensions.Height;
{// avcC
var avcc = new AvcC();
avcc.ProfileIndication = videoData.Sps[1];
avcc.Compatibility = videoData.Sps[2];
avcc.LevelIndication = videoData.Sps[3];
avcc.SequenceParameterSets = new byte[1][];
avcc.SequenceParameterSets[0] = videoData.Sps;
avcc.PictureParameterSets = new byte[1][];
avcc.PictureParameterSets[0] = videoData.Pps;
avc1.Children.Add(avcc);
}
{// Aspect ratio
var pasp = new AspectRatio();
avc1.Children.Add(pasp);
}
stsd.Children.Add(avc1);
}
stbl.Children.Add(stsd);
}
{// Time to Sample
var stts = new MatrixIO.IO.Bmff.Boxes.TimeToSampleBox();
stbl.Children.Add(stts);
}
{// Sample to Chunk
var stsc = new MatrixIO.IO.Bmff.Boxes.SampleToChunkBox();
stbl.Children.Add(stsc);
}
{// Sample size
var stsz = new MatrixIO.IO.Bmff.Boxes.SampleSizeBox();
stbl.Children.Add(stsz);
}
{// Chunk offset
var stco = new MatrixIO.IO.Bmff.Boxes.ChunkOffsetBox();
stbl.Children.Add(stco);
}
minf.Children.Add(stbl);
}
mdia.Children.Add(minf);
}
trak.Children.Add(mdia);
}
moov.Children.Add(trak);
}
{ // Movie extends
var mvex = new MatrixIO.IO.Bmff.Boxes.MovieExtendsBox();
{ // Track extends
var trex = new MatrixIO.IO.Bmff.Boxes.TrackExtendsBox();
trex.TrackID = 1;
trex.DefaultSampleDescriptionIndex = 1;
mvex.Children.Add(trex);
}
moov.Children.Add(mvex);
}
/*{// User data
* var udta = new MatrixIO.IO.Bmff.Boxes.UserDataBox();
* // TODO (e.g. ffmpeg mov_write_track_udta_tag writes title?)
* moov.Children.Add(udta);
* }*/
test.Children.Add(moov);
}
streamCursor = 0;
foreach (var box in test.Children)
{
streamCursor += box.CalculateSize();
}
sequenceCounter = 0;
totalCount = 0;
return(test);
}
