/// <summary>
/// Deletes the specified object from the <c>Likes</c> list of the current user.
/// </summary>
/// <param name="itemId">Object ID.</param>
/// <param name="type">Object type.</param>
/// <param name="ownerId">ID of the user or community that owns the object.</param>
/// <returns>Returns the number of users who still have this object in their Likes list. </returns>
public async Task<Response<int>> Delete(int itemId, MediaTypes type, int? ownerId = null)
=> await Request<int>("delete", new MethodParams
{
{"item_id", itemId, true},
{"type", Utils.ToEnumString(type), true},
{"owner_id", ownerId}
}, false, "likes");
private void Bind(IEnumerable <MediaType> mediaTypes)
{
MediaTypes.DataSource = mediaTypes.ToList();
MediaTypes.DataTextField = "Label";
MediaTypes.DataValueField = "ID";
MediaTypes.DataBind();
}
public void SegmentsWavCorrectly6Master()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(93),
SampleRate = 17460,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 279000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = false,
Channels = 2.AsArray(),
OffsetStart = TimeSpan.FromSeconds(27),
TargetSampleRate = 17460,
};
var util = TestHelper.GetAudioUtility();
var source = TestHelper.GetAudioFile("geckos.wav");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
public byte[] CreatePreview(byte[] bytes, MediaTypes mediaType, Size size)
{
using (var inStream = new MemoryStream(bytes))
{
return CreatePreview(inStream, mediaType, size);
}
}
/// <summary>
/// Get metadata for the given file.
/// </summary>
/// <param name="source">File to get metadata from. This should be an audio file.</param>
/// <returns>A dictionary containing metadata for the given file.</returns>
public override AudioUtilityInfo Info(FileInfo source)
{
var mediaType = MediaTypes.GetMediaType(source.Extension);
AudioUtilityInfo info;
if (mediaType == MediaTypes.MediaTypeWavpack)
{
if (this.wvunpackUtility == null)
{
throw new AudioFormatNotSupportedException(WavPackAudioUtility.MissingBinary);
}
info = this.Combine(this.wvunpackUtility.Info(source), this.ffmpegUtility.Info(source));
}
else if (mediaType == MediaTypes.MediaTypeMp3 && this.soxUtility.SupportsMp3)
{
info = this.Combine(this.soxUtility.Info(source), this.ffmpegUtility.Info(source));
}
else if (mediaType == MediaTypes.MediaTypeWav)
{
info = this.Combine(this.soxUtility.Info(source), this.ffmpegUtility.Info(source));
}
else if (mediaType == MediaTypes.MediaTypePcmRaw)
{
info = this.ffmpegRawPcmUtility.Info(source);
}
else
{
info = this.ffmpegUtility.Info(source);
}
return(info);
}
public IActionResult GetBlog(int userId, int blogId,
[FromHeader(Name = nameof(HeaderNames.Accept))] string mediaType)
{
if (!_weblogDataRepository.UserExists(userId))
{
return(NotFound());
}
var blogEntity = _weblogDataRepository.GetBlog(blogId);
if (blogEntity is null)
{
return(NotFound());
}
var blogToReturn = _mapper.Map <BlogDto>(blogEntity);
var includeLinks = MediaTypes.IncludeLinks(mediaType);
if (!includeLinks)
{
return(Ok(blogToReturn));
}
var links = CreateLinksForBlog(Url, userId, blogId);
var blogWithLinks = new BlogDtoWithLinks(blogToReturn, links);
return(Ok(blogWithLinks));
}
public static void Modify(
string filename,
AudioUtilityInfo sourceExpected,
AudioUtilityRequest request,
string outputMimeType,
AudioUtilityInfo outputExpected,
Action <AudioUtilityInfo, AudioUtilityInfo> additionalTests = null)
{
var source = PathHelper.GetTestAudioFile(filename);
var destExtension = MediaTypes.GetExtension(outputMimeType);
var outputFilename = Path.GetFileNameWithoutExtension(filename) + "_modified." + destExtension;
foreach (var util in new[] { TestHelper.GetAudioUtility() })
{
var dir = PathHelper.GetTempDir();
var output = new FileInfo(Path.Combine(dir.FullName, outputFilename));
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, outputMimeType, request);
var sourceInfo = util.Info(source);
TestHelper.CheckAudioUtilityInfo(sourceExpected, sourceInfo);
var outputInfo = util.Info(output);
var outputInfoText = GetDurationInfo(outputInfo);
additionalTests?.Invoke(sourceExpected, sourceInfo);
PathHelper.DeleteTempDir(dir);
}
}
/// <summary>
/// Set the media type formatter
/// </summary>
/// <param name="mediaType">The media type</param>
private protected void SetMediaTypeFormatter(MediaTypes mediaType)
{
switch (mediaType)
{
case MediaTypes.Bson:
MediaTypeFormatter = new BsonMediaTypeFormatter
{
SerializerSettings =
{
NullValueHandling = NullValueHandling.Ignore
}
};
break;
case MediaTypes.Xml:
MediaTypeFormatter = new XmlMediaTypeFormatter();
break;
default:
MediaTypeFormatter = new JsonMediaTypeFormatter
{
SerializerSettings =
{
NullValueHandling = NullValueHandling.Ignore
}
};
break;
}
}
public IActionResult Authenticate([FromBody] UserCredentialsDto credentials,
[FromHeader(Name = nameof(HeaderNames.Accept))] string mediaType)
{
var user = _weblogDataRepository.Authenticate(
credentials.EmailAddress, credentials.Password);
if (user is null)
{
return(Unauthorized());
}
var userToReturn = _mapper.Map <UserDto>(user);
var includeLinks = MediaTypes.IncludeLinks(mediaType);
if (!includeLinks)
{
return(Ok(userToReturn));
}
var links = CreateLinksForUser(user.UserId);
var userWithLinks = new UserDtoWithLinks(userToReturn, links);
return(Ok(userWithLinks));
}
/// <summary>
/// Validate to ensure that mime type and file extension match.
/// </summary>
/// <param name="source">
/// The source.
/// </param>
/// <param name="sourceMimeType">
/// The source mime type.
/// </param>
/// <exception cref="ArgumentException">
/// </exception>
/// <exception cref="ArgumentNullException"></exception>
protected void ValidateMimeTypeExtension(FileInfo source, string sourceMimeType)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (string.IsNullOrEmpty(sourceMimeType))
{
throw new ArgumentNullException(nameof(sourceMimeType));
}
if (!this.CheckMimeTypeExtension(source, sourceMimeType))
{
throw new ArgumentException(
string.Format(this.MimeTypeExtensionErrorFormatString, sourceMimeType, source.Extension),
nameof(sourceMimeType));
}
var ext = this.GetExtension(source);
if (!MediaTypes.IsFileExtRecognised(ext))
{
throw new ArgumentException($"Extension {ext} is not recognised.");
}
if (!MediaTypes.IsMediaTypeRecognised(sourceMimeType))
{
throw new ArgumentException($"Media type {sourceMimeType} is not recognised.");
}
}
public async Task <Media?> GetMediaBySearch(string search, MediaTypes type)
{
var query = $"query ($search: String $type: MediaType) {{ Media (search: $search type: $type) {QueryBuilder.GetMediaQuery()} }}";
var request = new GraphQLRequest {
Query = query, Variables = new { search, type }
};
GraphQLResponse <MediaResponse> response = null !;
try
{
response = await _graphQlClient.SendQueryAsync <MediaResponse>(request);
var characterCount = response.Data.Media.Characters.Edges.Length;
if (characterCount >= 25)
{
var additionalCharacters = await GetAllCharactersAsync(response.Data.Media.Id, 2);
additionalCharacters.AddRange(response.Data.Media.Characters.Edges);
response.Data.Media.Characters.Edges = additionalCharacters.ToArray();
}
}
catch (GraphQLHttpRequestException e)
{
if (e.StatusCode == HttpStatusCode.NotFound)
{
return(null); // media did not exist
}
}
return(response.Data.Media);
}
public ActionResult Handle(ControllerContext context)
{
if (!CanHandle(context))
{
return(null);
}
var model = context.Controller.ViewData.Model;
if (model == null)
{
return(null);
}
context.HttpContext.Response.ContentType = MediaTypes.First();
context.HttpContext.Response.ContentEncoding = Encoding.UTF8;
if (AlwaysReturnPartial || CustomViewExists(context))
{
return new PartialViewResult
{
ViewData = context.Controller.ViewData,
TempData = context.Controller.TempData,
ViewName = CustomViewExists(context) ? GetCustomViewName(context) : (string)context.RouteData.Values["action"],
}
}
;
return(OnHandle(context));
}
public void SegmentsWavpackCorrectly7Master()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromMinutes(10) + TimeSpan.FromSeconds(0),
SampleRate = 17460,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 279000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = true,
TargetSampleRate = 17460,
};
var util = TestHelper.GetAudioUtility();
var source = TestHelper.GetAudioFile("f969b39d-2705-42fc-992c-252a776f1af3_090705-0600.wv");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
/// <summary>
/// This will download the file and give the progress in % and bytes.
/// </summary>
/// <param name="strURL"></param>
public static async void downloadFile(string strURL)
{
try
{
backgroundDownloader = new BackgroundDownloader();
if (!string.IsNullOrEmpty(strURL))
{
string strVideoExtensions = "webm,mkv,flv,mp4,vob,gif,avi,mpeg,3gp";
string strImageExtensions = "jpeg,bmp,png,jpg";
string strTextExtensions = "txt";
string strExtension = string.Empty;
MediaTypes mediaType = 0;
strExtension = strURL.Substring(strURL.LastIndexOf('.'));
strExtension = strExtension.Split('.')[1];
if (strVideoExtensions.Contains(strExtension))
{
mediaType = MediaTypes.Video;
}
else if (strImageExtensions.Contains(strExtension))
{
mediaType = MediaTypes.Image;
}
else if (strTextExtensions.Contains(strExtension))
{
mediaType = MediaTypes.Text;
}
await CreateFolderAndFile(mediaType, strExtension);
MediaDownloader(strURL, mediaType);
}
}
catch (Exception ex)
{
}
}
public void SegmentsWavpackCorrectly3Wavunpack()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(55),
SampleRate = 22050,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 353000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = false,
OffsetStart = TimeSpan.FromSeconds(0),
OffsetEnd = TimeSpan.FromSeconds(55),
//SampleRate = 11025
};
var source = TestHelper.GetAudioFile("f969b39d-2705-42fc-992c-252a776f1af3_090705-0600.wv");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
TestHelper.GetAudioUtilityWavunpack().Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = TestHelper.GetAudioUtility().Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
public void SetObject(IMediaDetail selectedItem)
{
this.selectedItem = selectedItem;
if (selectedItem.ID != 0)
{
var allMediaTypes = MediaTypesMapper.GetDataModel().MediaTypes.Where(i => i.IsActive);
var allowedMediaTypes = new List <MediaType>();
foreach (var mediaType in allMediaTypes)
{
MediaTypeEnum mediaTypeEnum = MediaTypeEnum.Page;
Enum.TryParse(mediaType.Name, out mediaTypeEnum);
var tmpMediaDetail = MediaDetailsMapper.CreateObject(mediaTypeEnum);
if (tmpMediaDetail.GetType() == selectedItem.GetType())
{
allowedMediaTypes.Add(mediaType);
}
}
MediaTypes.DataSource = allowedMediaTypes;
MediaTypes.DataTextField = "Name";
MediaTypes.DataValueField = "ID";
MediaTypes.DataBind();
}
//UpdateFieldsFromObject();
}
/// <summary>
/// Validate this Audio Reading Request.
/// </summary>
/// <returns>
/// True if valid, otherwise false.
/// </returns>
public bool Validate()
{
if (!string.IsNullOrWhiteSpace(this.MediaType) && !MediaTypes.IsMediaTypeRecognised(this.MediaType))
{
return(false);
}
if (this.SampleRate.HasValue && this.SampleRate < 1)
{
return(false);
}
if (this.Channels.HasValue && this.Channels < 1)
{
return(false);
}
return(this.Start != TimeSpan.MaxValue &&
this.Start != TimeSpan.MinValue &&
this.Start >= TimeSpan.Zero &&
this.End != TimeSpan.MaxValue &&
this.End != TimeSpan.MinValue &&
this.End > TimeSpan.Zero &&
this.Start < this.End);
}
public async Task <IActionResult> PutMediaTypes(long id, MediaTypes mediaTypes)
{
if (id != mediaTypes.MediaTypeId)
{
return(BadRequest());
}
_context.Entry(mediaTypes).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MediaTypesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void FailsWithMissingBitDepth()
{
var request = new AudioUtilityRequest
{
//BitDepth = 16,
TargetSampleRate = 22050,
Channels = new[] { 1, 2, 3, 4 },
//BandPass
};
var tester = new FfmpegRawPcmAudioUtilityTester();
TestHelper.ExceptionMatches <InvalidOperationException>(
() =>
{
tester.InvokeCheckRequestValid(
this.source,
MediaTypes.GetMediaType(this.source.Extension),
this.output,
MediaTypes.GetMediaType(this.output.Extension),
request);
},
"A BitDepth must be supplied");
}
/// <summary>
/// Deletes the specified object from the <c>Likes</c> list of the current user.
/// </summary>
/// <param name="itemId">Object ID.</param>
/// <param name="type">Object type.</param>
/// <param name="ownerId">ID of the user or community that owns the object.</param>
/// <returns>Returns the number of users who still have this object in their Likes list. </returns>
public async Task <Response <int> > Delete(int itemId, MediaTypes type, int?ownerId = null)
=> await Request <int>("delete", new MethodParams
{
{ "item_id", itemId, true },
{ "type", Utils.ToEnumString(type), true },
{ "owner_id", ownerId }
}, false, "likes");
public void FailsWithInvalidBitDepth()
{
var request = new AudioUtilityRequest
{
BitDepth = 64,
TargetSampleRate = 22050,
Channels = new[] { 1, 2, 3, 4 },
//BandPass
};
var tester = new FfmpegRawPcmAudioUtilityTester();
TestHelper.ExceptionMatches <BitDepthOperationNotImplemented>(
() =>
{
tester.InvokeCheckRequestValid(
this.source,
MediaTypes.GetMediaType(this.source.Extension),
this.output,
MediaTypes.GetMediaType(this.output.Extension),
request);
},
"Supplied bit depth of 64");
}
/// <summary>
/// The prepare file.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
public static AudioUtilityModifiedInfo PrepareFile(FileInfo sourceFile, FileInfo outputFile, AudioUtilityRequest request, DirectoryInfo temporaryFilesDirectory)
{
var audioUtility = new MasterAudioUtility(temporaryFilesDirectory);
var sourceMimeType = MediaTypes.GetMediaType(sourceFile.Extension);
var outputMimeType = MediaTypes.GetMediaType(outputFile.Extension);
string outputDirectory = Path.GetDirectoryName(outputFile.FullName);
if (!Directory.Exists(outputDirectory))
{
Directory.CreateDirectory(outputDirectory);
}
audioUtility.Modify(
sourceFile,
sourceMimeType,
outputFile,
outputMimeType,
request);
var result = new AudioUtilityModifiedInfo
{
TargetInfo = audioUtility.Info(outputFile),
SourceInfo = audioUtility.Info(sourceFile),
};
return(result);
}
/// <summary>
/// Segment a <paramref name="source"/> audio file.
/// <paramref name="output"/> file will be created.
/// </summary>
/// <param name="source">
/// The <paramref name="source"/> audio file.
/// </param>
/// <param name="sourceMediaType">
/// The <paramref name="source"/> Mime Type.
/// </param>
/// <param name="output">
/// The <paramref name="output"/> audio file. Ensure the file does not exist.
/// </param>
/// <param name="outputMediaType">
/// The <paramref name="output"/> Mime Type.
/// </param>
/// <param name="request">
/// The segment <paramref name="request"/>.
/// </param>
public virtual void Modify(FileInfo source, string sourceMediaType, FileInfo output, string outputMediaType, AudioUtilityRequest request)
{
this.CheckFile(source);
sourceMediaType = MediaTypes.CanonicaliseMediaType(sourceMediaType);
outputMediaType = MediaTypes.CanonicaliseMediaType(outputMediaType);
this.ValidateMimeTypeExtension(source, sourceMediaType, output, outputMediaType);
this.CanProcess(source, this.ValidSourceMediaTypes, this.InvalidSourceMediaTypes);
this.CanProcess(output, this.ValidOutputMediaTypes, this.InvalidOutputMediaTypes);
request.ValidateChecked();
this.CheckRequestValid(source, sourceMediaType, output, outputMediaType, request);
this.CheckRequestValidForMediaType(output, outputMediaType, request);
using (var process = new ProcessRunner(this.ExecutableModify.FullName))
{
string args = this.ConstructModifyArgs(source, output, request);
this.RunExe(process, args, output.DirectoryName);
}
if (this.Log.IsDebugEnabled)
{
this.Log.Trace("Source " + this.BuildFileDebuggingOutput(source));
this.Log.Trace("Output " + this.BuildFileDebuggingOutput(output));
}
this.CheckFile(output);
}
public async Task UpdateNowPlaying(string itemsJSON, MediaTypes mediaType)
{
var items = JsonConvert.DeserializeObject <IEnumerable <ListItem <int, int> > >(itemsJSON);
Configuration configuration = await dataService.Get <Configuration>(item => item.Type == nameof(MediaPages.Player));
PlayerConfiguration playerConfiguration = new PlayerConfiguration();
if (configuration == null)
{
configuration = new Configuration()
{
Type = nameof(MediaPages.Player), JsonData = JsonConvert.SerializeObject(playerConfiguration)
};
await dataService.Insert(configuration);
}
else
{
playerConfiguration = JsonConvert.DeserializeObject <PlayerConfiguration>(configuration.JsonData) ?? new PlayerConfiguration();
}
playerConfiguration.CurrentItemIndex = items.FirstOrDefault((item) => item.IsSelected)?.Id ?? 0;
playerConfiguration.SelectedMediaType = mediaType;
configuration.JsonData = JsonConvert.SerializeObject(playerConfiguration);
await dataService.Update(configuration);
if (items != null) /*then*/ playerService {
/// <summary>
/// Get Guid of specified MediaType
/// </summary>
/// <param name="mt"></param>
/// <returns></returns>
public static Guid GetMediaGuid(MediaTypes mt)
{
if (mt == MediaTypes.Image)
{
return(new Guid("22258901-AD26-42F0-BC1B-C902FD542562"));
}
else if (mt == MediaTypes.Video)
{
return(new Guid("D1D0F4A5-1795-43A9-9B4F-6120261BA1B0"));
}
else if (mt == MediaTypes.Audio)
{
return(new Guid("50727BB2-CD08-4C78-9C02-F514D40EB148"));
}
else if (mt == MediaTypes.Photosynth)
{
return(new Guid("8CBAF86D-8D55-450D-8BE0-187081A42F7B"));
}
else if (mt == MediaTypes.PDF)
{
return(new Guid("DA810942-8569-4B84-9590-E2FDAD61F0C9"));
}
else
{
return(new Guid());
}
}
private void FillDataInGrid()
{
string Status = ddlStatus.SelectedValue;
MediaTypes media_type_obj = new MediaTypes();
List <Media_Types> lst = media_type_obj.GetListByStatus(Status);
//if (lst.Rows.Count > 0)
//{
GridView1.DataSource = lst;
GridView1.DataBind();
//}
//else
//{
// dt.Rows.Add(dt.NewRow());
// GridView1.DataSource = dt;
// GridView1.DataBind();
// int TotalColumns = GridView1.Rows[0].Cells.Count;
// GridView1.Rows[0].Cells.Clear();
// GridView1.Rows[0].Cells.Add(new TableCell());
// GridView1.Rows[0].Cells[0].ColumnSpan = TotalColumns;
// GridView1.Rows[0].Cells[0].Text = "No Record Found";
//}
}
/// <summary>
/// Create thumbs for specific item
/// </summary>
/// <param name="ciGuid">ContentItem to create thumbnail of</param>
public void MakeThumbsForItem(ContentItem ci)
{
MediaTypes mt = MediaType.GetMediaType(ci.MediaTypeID);
if (mt == MediaTypes.Video || mt == MediaTypes.Image || mt == MediaTypes.PDF || mt == MediaTypes.Photosynth)
{
mrLogger.Log("Making thumbs for content item with id " + ci.ID.ToString());
// Create bitmaps of Infodot
BitmapSource[] resultBmps = Thumbs.MakeThumbs(ci, Utils.GetSizes(), InitialSize);
if (resultBmps == null)
{
string c = "Cannot create thumbnails for Content Item with ID " + ci.ID.ToString() + ", skipping.";
Console.WriteLine(c);
mrLogger.Log(c);
return;
}
// Save thumbnails
foreach (BitmapSource bmp in resultBmps)
{
SaveThumbnailAsPng(bmp, ci.ID);
}
}
else
{
string ms = "Media Type for Content Item " + ci.ID.ToString() + " is not supported";
Console.WriteLine(ms);
mrLogger.Log(ms);
}
}
public void SegmentsWavCorrectly4()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(60),
SampleRate = 22050,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 353000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = true,
OffsetStart = TimeSpan.FromSeconds(15),
OffsetEnd = TimeSpan.FromSeconds(75),
};
var util = TestHelper.GetAudioUtility();
var source = TestHelper.GetAudioFile("FemaleKoala MaleKoala.wav");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
/// <summary>
/// Determines kind of the media in the content item and returns image
/// </summary>
/// <param name="ciData"></param>
/// <returns></returns>
private static BitmapSource GetMediaThumbnail(ContentItem ciData)
{
BitmapSource bmp;
string mediasrc = ciData.MediaTypeID.ToString().ToLower();
MediaTypes mtype = MediaType.GetMediaType(ciData.MediaTypeID);
try
{
if (mtype == MediaTypes.Image)
{
bmp = (BitmapImage)Utils.GetImage(new Uri(ciData.MediaBlobURL));
}
else
{
bmp = Utils.GenerateScreenshot(ciData.MediaBlobURL);
}
}
catch (UriFormatException e)
{
Console.WriteLine(e.Message);
bmp = null;
}
return(bmp);
}
public Task <FileSegment> PrepareFile <TSource>(
DirectoryInfo outputDirectory,
ISegment <TSource> source,
string outputMediaType,
int?targetSampleRateHz,
DirectoryInfo temporaryFilesDirectory,
int[] channelSelection,
bool?mixDownToMono)
{
int min = (int)source.StartOffsetSeconds.Seconds().TotalMinutes;
if (typeof(TSource) != typeof(FileInfo))
{
throw new NotSupportedException("Dummy Source Preparer only works with FileInfos");
}
var basename = Path.GetFileNameWithoutExtension((source.Source as FileInfo).Name);
return(Task.Run(() =>
{
var path = outputDirectory.CombineFile(basename + $"_{min}min." + MediaTypes.GetExtension(outputMediaType));
using (var file = path.CreateText())
{
file.WriteLine(
$"{outputDirectory},{source},{outputMediaType},{source.StartOffsetSeconds},{source.EndOffsetSeconds},{targetSampleRateHz}"
+ $",{temporaryFilesDirectory},{channelSelection},{mixDownToMono}");
}
return new FileSegment(path, targetSampleRateHz.Value, (source.EndOffsetSeconds - source.StartOffsetSeconds).Seconds());
}));
}
private static string GetNewName(FileInfo file, TimeSpan timezone)
{
var fileName = file.Name;
var fileLength = file.Length;
var lastModified = file.LastWriteTime;
var mediaType = MediaTypes.GetMediaType(file.Extension);
var audioUtility = new MasterAudioUtility();
var info = audioUtility.Info(file);
var duration = info.Duration.HasValue ? info.Duration.Value : TimeSpan.Zero;
var recordingStart = lastModified - duration;
// some tweaking to get nice file names - round the minutes of last mod and duration
// ticks are in 100-nanosecond intervals
//var modifiedRecordingStart = lastModified.Round(TimeSpan.FromSeconds(15))
// - duration.Round(TimeSpan.FromSeconds(15));
//// DateTime rounded = new DateTime(((now.Ticks + 25000000) / 50000000) * 50000000);
////var roundedTotalSeconds = Math.Round(mediaFile.RecordingStart.TimeOfDay.TotalSeconds);
////var modifiedRecordingStart = mediaFile.RecordingStart.Date.AddSeconds(roundedTotalSeconds);
var dateWithOffset = new DateTimeOffset(recordingStart, timezone);
var dateTime = dateWithOffset.ToUniversalTime().ToString(AppConfigHelper.StandardDateFormatUtc);
var ext = fileName.Substring(fileName.LastIndexOf('.') + 1).ToLowerInvariant();
var prefix = fileName.Substring(0, fileName.LastIndexOf('.'));
var result = string.Format("{0}_{1}.{2}", prefix, dateTime, ext);
return(result);
}
public byte[] CropImage(byte[] bytes, MediaTypes mediaType, Rectangle rectangle)
{
using (var inStream = new MemoryStream(bytes))
{
return CropImage(inStream, mediaType, rectangle);
}
}
public void SegmentsWavCorrectly2Sox()
{
var expected = new AudioUtilityInfo
{
Duration = TimeSpan.FromSeconds(35),
SampleRate = 17460,
ChannelCount = 1,
MediaType = MediaTypes.MediaTypeWav,
BitsPerSecond = 279000,
};
var request = new AudioUtilityRequest
{
MixDownToMono = true,
OffsetEnd = TimeSpan.FromSeconds(35),
TargetSampleRate = 17460,
};
var util = TestHelper.GetAudioUtilitySox();
var source = TestHelper.GetAudioFile("Lewins Rail Kekkek.wav");
var output = PathHelper.GetTempFile(MediaTypes.ExtWav);
util.Modify(source, MediaTypes.GetMediaType(source.Extension), output, MediaTypes.GetMediaType(output.Extension), request);
var actual = util.Info(output);
File.Delete(output.FullName);
TestHelper.CheckAudioUtilityInfo(expected, actual);
}
/// <summary>
/// Checks for the object in the <c>Likes</c> list of the specified user.
/// </summary>
/// <param name="itemId">Object ID.</param>
/// <param name="type">Object type.</param>
/// <param name="userId">User ID. </param>
/// <param name="ownerId">ID of the user or community that owns the object.</param>
/// <returns>Returns True if the object is in the user's Likes list; otherwise returns False.</returns>
public async Task<Response<MediaLiked>> IsLiked(int itemId, MediaTypes type, int? userId = null,
int? ownerId = null) => await Request<MediaLiked>("isLiked", new MethodParams
{
{"item_id", itemId, true},
{"type", Utils.ToEnumString(type), true},
{"user_id", userId},
{"owner_id", ownerId}
});
/// <summary>
/// Adds the specified object to the <c>Likes</c> list of the current user.
/// </summary>
/// <param name="itemId">Object ID.</param>
/// <param name="type">Object type.</param>
/// <param name="ownerId">ID of the user or community that owns the object.</param>
/// <param name="accessKey">Access key required for an object owned by a private entity.</param>
/// <param name="r"></param>
/// <returns>Returns the current number of users who added this object to their Likes list. </returns>
public async Task<Response<int>> Add(int itemId, MediaTypes type, int? ownerId = null, string accessKey = null,
string r = null) => await Request<int>("add", new MethodParams
{
{"item_id", itemId, true},
{"type", Utils.ToEnumString(type), true},
{"owner_id", ownerId},
{"access_key", accessKey},
{"ref", r}
}, false, "likes");
public void SetImage(Image image, MediaTypes type)
{
this.m_status = Statuses.Complete;
this.m_image = image;
this.m_type = type;
this.CheckPosition();
this.Invalidate();
}
public static Data Create(Guid id, byte[] bytes, MediaTypes mimeType)
{
var result = new Data
{
Id = id,
Bytes = bytes,
MimeType = mimeType.ToString()
};
return result;
}
private IDataParser GetParser(MediaTypes type)
{
switch (type)
{
case MediaTypes.Wma:
return null;
case MediaTypes.Mp3:
return new ID3Parser();
default:
throw new ArgumentException("Unknown media type.");
}
}
/// <summary>
/// Get Guid of specified MediaType
/// </summary>
/// <param name="mt"></param>
/// <returns></returns>
public static Guid GetMediaGuid(MediaTypes mt)
{
if (mt == MediaTypes.Image)
return new Guid("22258901-AD26-42F0-BC1B-C902FD542562");
else if (mt == MediaTypes.Video)
return new Guid("D1D0F4A5-1795-43A9-9B4F-6120261BA1B0");
else if (mt == MediaTypes.Audio)
return new Guid("50727BB2-CD08-4C78-9C02-F514D40EB148");
else if (mt == MediaTypes.Photosynth)
return new Guid("8CBAF86D-8D55-450D-8BE0-187081A42F7B");
else if (mt == MediaTypes.PDF)
return new Guid("DA810942-8569-4B84-9590-E2FDAD61F0C9");
else
return new Guid();
}
public static bool TryMimeTypeCast(MediaTypes mediaType,
out int mediaTypeIndex,
int defaultMediaTypeIndex = DefaultMediaTypeIndex)
{
var result = true;
try
{
mediaTypeIndex = (int)mediaType;
}
catch
{
mediaTypeIndex = defaultMediaTypeIndex;
result = false;
}
return result;
}
public byte[] CreatePreview(Stream stream, MediaTypes mediaType, Size size)
{
byte[] result;
var format = mediaType.DetectFormat();
var resizeLayer = new ResizeLayer(size, ResizeMode.Crop);
stream.ResetStream();
using (var outStream = new MemoryStream())
{
using (var imageFactory = new ImageFactory(preserveExifData: true))
{
imageFactory.Load(stream)
.Format(format)
.Resize(resizeLayer)
.Save(outStream);
}
result = outStream.ToArray();
}
return result;
}
public byte[] CropImage(Stream stream, MediaTypes mediaType, Rectangle rectangle)
{
byte[] result;
var format = mediaType.DetectFormat();
stream.ResetStream();
using (var outStream = new MemoryStream())
{
using (var imageFactory = new ImageFactory())
{
imageFactory.Load(stream)
.Format(format)
.Crop(rectangle)
.Save(outStream);
}
result = outStream.ToArray();
}
return result;
}
public string GetAllData(long SchemaId, string ApiKey, MediaTypes MediaType, int Limit = 100)
{
//cek akses by ApiKey
//get schemaid to determine dbtype
var item = getSchemaById(SchemaId);
if (item != null)
{
var DbName = SchemaDb.GetDbName(item.CreatedBy);
foreach (var iDb in Db)
{
iDb.Value.SetupDatabase(DbName);
}
(Db[SchemaTypes.HistoricalData] as ColumnarDb).UserName = item.CreatedBy;
List<dynamic> tsk = Task.Run(async () =>
await Db[item.SchemaType].GetAllData(Limit, item.SchemaName)).Result;
if (MediaType == MediaTypes.XML)
{
XElement hasil = SchemaConverter.ExpandoToXML(tsk, item.SchemaName);
return hasil.ToString();
}
else
{
return JsonConvert.SerializeObject(tsk);
}
}
return string.Empty;
}
public string GetDataWithFilter(long SchemaId, string ApiKey, MediaTypes MediaType,string Filter, int Limit = 100)
{
//cek akses by ApiKey
//get schemaid to determine dbtype
var item = getSchemaById(SchemaId);
if (item != null)
{
var DbName = SchemaDb.GetDbName(item.CreatedBy);
foreach (var iDb in Db)
{
iDb.Value.SetupDatabase(DbName);
}
(Db[SchemaTypes.HistoricalData] as ColumnarDb).UserName = item.CreatedBy;
List<dynamic> temp = Task.Run(async () =>
await Db[item.SchemaType].GetAllData(Limit, item.SchemaName)).Result;
//I don't have better way to do this.. roslyn doesn't support dynamic lambda
var dt = SchemaConverter.ExpandoToDataTable(temp);
//using dynamic linq to filter data
var filteredData = dt.Select(Filter).Take(Limit).Select(r => r.Table.Columns.Cast<DataColumn>()
.Select(c => new KeyValuePair<string, object>(c.ColumnName, r[c.Ordinal])
).ToDictionary(z => z.Key, z => z.Value)
).ToList();
if (MediaType == MediaTypes.XML)
{
XElement hasil = SchemaConverter.ExpandoToXML(filteredData, item.SchemaName);
return hasil.ToString();
}
else
{
var hasil = JsonConvert.SerializeObject(filteredData, Formatting.Indented);
return hasil;
}
}
return string.Empty;
}
public string GetDataWithQuery(string ApiKey, MediaTypes MediaType, string Query, int Limit = 100)
{
//cek akses by ApiKey
var uid = HttpContext.Current.User.Identity.Name;
if (!string.IsNullOrEmpty(uid))
{
var DbName = SchemaDb.GetDbName(uid);
foreach (var iDb in Db)
{
iDb.Value.SetupDatabase(DbName);
}
(Db[SchemaTypes.HistoricalData] as ColumnarDb).UserName = uid;
//var dbService = new DBService();
var temp = Task.Run(async () => await DBService.Execute(Query, Limit)).Result;
if (MediaType == MediaTypes.XML)
{
XElement hasil = SchemaConverter.ExpandoToXML(temp, "data");
return hasil.ToString();
}
else
{
var hasil = JsonConvert.SerializeObject(temp);
return hasil;
}
}
return string.Empty;
}
public FileAddParameter(string name, Stream stream, MediaTypes mediaType)
{
Name = name;
Stream = stream;
MediaType = mediaType;
}
private static string FixUrl(string url, out MediaTypes mediaType)
{
mediaType = MediaTypes.Image;
if (url.Contains("tweet_video_thumb"))
{
mediaType = MediaTypes.Video;
return url.Replace("tweet_video_thumb", "tweet_video").Replace(".png", ".mp4");
}
if (url.Contains("ext_tw_video"))
{
mediaType = MediaTypes.VideoThumb;
return url.EndsWith(":orig") ? url : url + ":orig";
}
if (url.Contains("pbs.twimg.com"))
return url.EndsWith(":orig") ? url : url + ":orig";
if (url.Contains("p.twipple.jp/"))
return url.Replace("p.twipple.jp/", "p.twpl.jp/show/orig/");
if (url.Contains("twitrpix.com/"))
return url.Replace("twitrpix.com/", "img.twitrpix.com/");
if (url.Contains("img.ly/"))
return url.Replace("img.ly/", "img.ly/show/full/");
if (url.Contains("lockerz.com/s/"))
return url.Replace("lockerz.com/s/", "api.plixi.com/api/tpapi.svc/imagefromurl?url=http://plixi.com/p/") + "&size=big";
if (url.Contains("pikchur.com/"))
return url.Replace("pikchur.com/", "img.pikchur.com/pic_") + "_l.jpg";
if (url.Contains("puu.sh/"))
return url;
if (url.Contains("pckles.com"))
return url;
if (url.Contains("twitpic.com"))
return url.Replace("twitpic.com", "www.twitpic.com/show/full/");
if (url.EndsWith(".png") || url.EndsWith(".jpg") || url.EndsWith(".gif"))
return url;
Match m;
m = regYoutube.Match(url);
if (m.Success)
{
mediaType = MediaTypes.VideoThumb;
return string.Format("http://img.youtube.com/vi/{0}/sddefault.jpg", m.Groups[1].Value);
}
m = regVine.Match(url);
if (m.Success)
{
mediaType = MediaTypes.Video;
return url;
}
mediaType = MediaTypes.PageThumb;
return url;
}
public MediaParser(MediaTypes types)
{
foreach (MediaTypes type in Enum.GetValues(typeof (MediaTypes)))
if (types.HasFlag(type))
_parsers.Add(type, GetParser(type));
}
public static string GetMimeTypeIcon(this HtmlHelper html, MediaTypes mediaType)
{
var result = Path.Combine(DirectoryNameConst.MimeTypeDirectory, mediaType + MimeTypeIconFormat);
return result;
}
public byte[] Rotate(Stream stream, MediaTypes mediaType, RotateTypes rotateType)
{
byte[] result;
var format = mediaType.DetectFormat();
var rotateStep = RotateUtility.GetRotateStep(rotateType);
stream.ResetStream();
using (var outStream = new MemoryStream())
{
using (var imageFactory = new ImageFactory())
{
imageFactory.Load(stream)
.Format(format)
.Rotate(rotateStep)
.Save(outStream);
}
result = outStream.ToArray();
}
return result;
}
public static ImageComplex Create(Guid originalId, Guid previewId, MediaTypes mediaType, string imageName)
{
var result = new ImageComplex
{
Id = originalId,
OriginalId = originalId,
PreviewId = previewId,
MediaType = mediaType,
Name = imageName
};
return result;
}
public DataParameter(Guid id, MediaTypes mediaType)
{
Id = id;
MimeType = mediaType.ToString();
}
public byte[] OriginalProcess(byte[] bytes, MediaTypes mediaType, Size maxSize)
{
byte[] result;
using (var inStream = new MemoryStream(bytes))
{
result = OriginalProcess(inStream, mediaType, maxSize);
}
return result;
}
private void UpdateMediaType()
{
string tipAudio = Translator.Translate("TXT_AUDIO_AVAILABLE");
string tipVideo = Translator.Translate("TXT_VIDEO_AVAILABLE");
if (string.IsNullOrEmpty(_mediaName))
{
_mediaType = MediaTypes.None;
}
switch (_mediaType)
{
case MediaTypes.None:
tslAudioOn.Image = null;
tslVideoOn.Image = null;
break;
case MediaTypes.Audio:
tslAudioOn.Image = Resources.AudioMediaType;
tslVideoOn.Image = null;
break;
case MediaTypes.Video:
tslAudioOn.Image = null;
tslAudioOn.Image = Resources.VideoMediaType;
break;
case MediaTypes.Both:
tslAudioOn.Image = Resources.AudioMediaType;
tslVideoOn.Image = Resources.VideoMediaType;
break;
}
tslAudioOn.Tag = tipAudio;
tslVideoOn.Tag = tipVideo;
}
public byte[] Rotate(byte[] bytes, MediaTypes mediaType, RotateTypes rotateType)
{
byte[] result;
using (var inStream = new MemoryStream(bytes))
{
result = Rotate(inStream, mediaType, rotateType);
}
return result;
}
public byte[] OriginalProcess(Stream stream, MediaTypes mediaType, Size maxSize)
{
byte[] result;
var format = mediaType.DetectFormat();
var imageSize = GetSize(stream);
var targetSize = imageSize.TargetSize(maxSize);
stream.ResetStream();
using (var outStream = new MemoryStream())
{
using (var imageFactory = new ImageFactory())
{
imageFactory.Load(stream)
.Format(format)
.Resize(targetSize)
.Save(outStream);
}
result = outStream.ToArray();
}
return result;
}
private void SetMediaTypeIcons()
{
LogDebug("(IDisplay) ImonLcd.SetMediaTypeIcons() called");
MediaTypes newMediaTypes = MediaTypes.None;
_activeWindowInfo.ActiveWindow = GUIWindowManager.ActiveWindow;
if (_activeWindowInfo.IsWeather)
{
newMediaTypes |= MediaTypes.News_Weather;
LogDebug("(IDisplay) ImonLcd.SetMediaTypeIcons(): in weather plugin");
}
if (g_Player.Player != null && g_Player.Player.Playing)
{
if (g_Player.IsCDA)
{
newMediaTypes |= MediaTypes.Cd_Dvd;
newMediaTypes |= MediaTypes.Music;
}
if (g_Player.IsDVD || g_Player.IsDVDMenu)
{
newMediaTypes |= MediaTypes.Cd_Dvd;
newMediaTypes |= MediaTypes.Movie;
}
if (g_Player.IsMusic)
{
newMediaTypes |= MediaTypes.Music;
}
if (g_Player.IsTV || g_Player.IsTVRecording)
{
newMediaTypes |= MediaTypes.Tv;
}
if (g_Player.IsVideo)
{
newMediaTypes |= MediaTypes.Movie;
}
if (_activeWindowInfo.IsWebCasting)
{
newMediaTypes |= MediaTypes.WebCasting;
}
LogDebug("(IDisplay) ImonLcd.SetMediaTypeIcons(): determined media type: " + newMediaTypes);
}
if (_currentMediaTypes != newMediaTypes)
{
LogDebug("(IDisplay) ImonLcd.SetMediaTypeIcons(): new settings found, call API");
IDW_SetLcdMediaTypeIcon((byte)newMediaTypes);
_currentMediaTypes = newMediaTypes;
}
LogDebug("(IDisplay) ImonLcd.SetMediaTypeIcons() completed");
}
internal void FilterStateChanged(FilterState filterState, string mediaName,
MediaTypes mediaType)
{
playbackPanel.MediaName = mediaName;
playbackPanel.FilterState = filterState;
playbackPanel.MediaType = mediaType;
}
