private void m_MetaChanged(MediaBase sender, VlcEventArgs <Metadatas> e)
{
Dispatcher.BeginInvoke(new Action(async() =>
{
try
{
var title = _vlc.Media?.Metadatas?.Title;
if (string.IsNullOrEmpty(title))
{
return;
}
var txt = Encoding.UTF8.GetString(Encoding.Default.GetBytes(title));
if (Uri.IsWellFormedUriString(txt, UriKind.Absolute))
{
return;
}
if (txt?.Length < 320)
{
await Send("nowplaying", txt);
}
}
catch
{
//Collection was modified; enumeration operation may not execute.
}
}), DispatcherPriority.Background);
}
private async void M_MediaSubItemAdded(MediaBase sender, VlcEventArgs <MediaBase> e)
{
_subCounter++;
await Send("navigatable", _subCounter > 2);
SetHandlersForMedia(e.Data);
}
private void media_StateChanged(MediaBase sender, VlcEventArgs <Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States> e)
{
if (e.Data == Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Stopped)
{
this.btn_play.Content = "\uf04b";
}
else if (e.Data == Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Paused)
{
if (this.MediaState == MTC_Player.MediaState.Playing)
{
if (sender.Duration.TotalSeconds - this.durationMedia.TotalSeconds < 1)
{
myVlcControl.Position = 0f;
myVlcControl.Play();
}
else
{
this.btn_play.Content = "\uf04b";
myVlcControl.Stop();
}
}
}
else if (e.Data == Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Playing)
{
this.btn_play.Content = "\uf04c";
}
}
void SetHandlersForMedia(MediaBase media)
{
media.MediaSubItemAdded += M_MediaSubItemAdded;
media.MetaChanged += m_MetaChanged;
media.StateChanged += (oo, ee) => Dispatcher.BeginInvoke(new Action(async() =>
{
switch (media.State)
{
case States.Playing:
try
{
if (_currentMedia?.SubItems.Count > 0)
{
var m = (LocationMedia)media;
var lst = ((LocationMedia)_currentMedia).SubItems;
if (lst.Count > 1 && lst.Any(mm => mm.MRL == m.MRL))
{
await Send("chapterchanged", lst.IndexOf(lst.First(mm => mm.MRL == m.MRL)) + 1);
}
}
_hasSubtitles = _vlc.VideoProperties.SpuDescription != null &&
_vlc.VideoProperties.SpuDescription.Next != null;
}
catch
{
}
await Send("playing", "");
break;
case States.Opening:
await Send("opening");
break;
}
}), DispatcherPriority.Background);
}
public async Task <MediaBase> GetMediaByIDAsync(string id)
{
var message = await m_client.GetAsync("https://api.themoviedb.org/3/tv/" + id + "?api_key=295f15628e2e84110ce9197ae94e652b");
JObject json = JObject.Parse(await message.Content.ReadAsStringAsync());
MediaBase movie = await ParseMediaFromJsonAsync(json, false);
return(movie);
}
public async Task <IActionResult> Index()
{
#region Cache Response
var existingMovies = await GetResponseAndSaveToCache(new GetExistingMoviesRequest()
{
Amount = _takeAmount
});
var radarrHistory = await GetResponseAndSaveToCache(new GetHistoryRequest { Order = Order.desc, Page = 1, PageSize = 20 });
var latestEpisode = await GetResponseAndSaveToCache(new GetLatestEpisodeRequest()
{
Order = Order.desc, PageSize = 1
});
#endregion
var first = new List <HistoryBase>()
{
radarrHistory.History.Records.FirstOrDefault(),
latestEpisode.History.Records.FirstOrDefault()
}.OrderByDescending(x => x.Date).FirstOrDefault();
var lastUpdated = new MediaBase();
if (first is Domain.API_Responses.Radarr.v3.Record)
{
var latest = await _mediator.Send(new GetSingleExistingMovieRequest {
RadarrMovieId = radarrHistory.History.Records.FirstOrDefault(x => x.EventType.Equals(ApiConstants.Imported)).MovieId.ToString()
});
lastUpdated = latest.Movie as MediaBase;
}
else
{
var latest = await _mediator.Send(new GetSingleSeriesRequest(latestEpisode.History.Records.FirstOrDefault(x => x.EventType.Equals(ApiConstants.Imported)).SeriesId));
lastUpdated = latest.TvShow as MediaBase;
}
var model = new IndexViewModel()
{
LatestMovie = lastUpdated,
LatestSeries = latestEpisode.History,
PartialView = new IndexListPartialViewModel
{
Movies = existingMovies.Movies.Take(_takeAmount),
TotalPages = existingMovies.TotalPages,
CurrentPage = existingMovies.CurrentPage,
}
};
return(View(model));
}
/// <summary>
/// Called by <see cref="VlcControl.Media"/> when the media information was parsed.
/// </summary>
/// <param name="sender">Event sending media. </param>
/// <param name="e">VLC event arguments. </param>
private void MediaOnParsedChanged(MediaBase sender, VlcEventArgs <int> e)
{
textBlock.Text = string.Format(
"Duration: {0:00}:{1:00}:{2:00}",
myVlcControl.Media.Duration.Hours,
myVlcControl.Media.Duration.Minutes,
myVlcControl.Media.Duration.Seconds);
sliderVolume.Value = myVlcControl.AudioProperties.Volume;
checkboxMute.IsChecked = myVlcControl.AudioProperties.IsMute;
}
private static void LoadMediaBase(MediaBase entity, Media media)
{
entity.Id = media.Id;
entity.ParentId = media.ParentId;
entity.CreateDateTime = media.CreateDateTime;
entity.IsTrashed = media.IsTrashed;
entity.FileExtension = media.getProperty("umbracoExtension").Value.ToString();
entity.RelativePathToFile = media.HasProperty("umbracoFile") ? media.getProperty("umbracoFile").Value.ToString() : string.Empty;
entity.FileSize = Convert.ToInt64(media.getProperty("umbracoBytes").Value.ToString());
}
public void baseMedia()
{
if (this.LocalFile != null)
{
this._media = new PathMedia(this.LocalFile.FullName);
}
else if (this.TypeMedia.Code == "URL")
{
this._media = new LocationMedia(this.Url);
}
}
private bool InternalExecute(MediaBase inputMedia)
{
Debug.WriteLine(this, "Loudness operation started");
string Params = $"-nostats -i \"{inputMedia.FullPath}\" -ss {MeasureStart} -t {(MeasureDuration == TimeSpan.Zero ? inputMedia.DurationPlay : MeasureDuration)} -filter_complex ebur128=peak=sample -f null -";
if (RunProcess(Params))
{
Debug.WriteLine(this, "Loudness operation succeed");
OperationStatus = FileOperationStatus.Finished;
return(true);
}
Debug.WriteLine("FFmpeg rewraper Execute(): Failed for {0}. Command line was {1}", Source, Params);
return(false);
}
void Awake()
{
DontDestroyOnLoad(gameObject);
#if UNITY_EDITOR
_media = gameObject.AddComponent <MediaStandalone>();
#elif UNITY_ANDROID
_media = gameObject.AddComponent <MediaAndroid>();
#elif UNITY_IOS
_media = gameObject.AddComponent <MediaIOS>();
#elif UNITY_WEBGL
_media = gameObject.AddComponent <MediaWebGL>();
#else
Debug.LogError("NOT IMPLEMENTED");
#endif
}
void media_StateChanged(MediaBase sender, VlcEventArgs <Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States> e)
{
switch (e.Data)
{
case Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Buffering:
LoadingVisual.Visibility = Visibility.Visible;
break;
case Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Playing:
LoadingVisual.Visibility = Visibility.Collapsed;
break;
case Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.NothingSpecial:
break;
}
}
private async Task <MediaBase> ParseMediaFromJsonAsync(JObject json, List <MediaBase> mediaList = null)
{
await UpdateAuthTokenAsync();
string id = json["id"].ToString();
var message = await m_client.GetAsync($"https://api.thetvdb.com/series/{id}");
JObject result = JObject.Parse(await message.Content.ReadAsStringAsync());
result = JObject.Parse(result["data"].ToString());
if (!result.ContainsKey("id"))
{
return(null);
}
string tvdbid = result["id"].ToString();
JArray genres = JArray.Parse(result["genre"].ToString());
foreach (JToken genre in genres.Children())
{
if (genre.ToString() == "Anime")
{
return(null);
}
}
if (!await m_indexer.DoesShowExistAsync(tvdbid))
{
return(null);
}
if (tvdbid == null || tvdbid == string.Empty)
{
return(null);
}
string posterPath = result["poster"].ToString();
if (posterPath == null || posterPath == string.Empty)
{
return(null);
}
MediaBase media = new MediaBase(result["seriesName"].ToString(), result["overview"].ToString(), m_basePosterURL + posterPath, id, tvdbid);
if (mediaList != null)
{
mediaList.Add(media);
}
return(media);
}
private void PlayMedia(MediaBase media)
{
if (media != null)
{
if (myVlcControl.Medias != null && myVlcControl.Medias.Count > 0)
{
myVlcControl.Medias.Clear();
}
media.StateChanged -= media_StateChanged;
media.StateChanged += media_StateChanged;
media.ParsedChanged -= media_ParsedChanged;
media.ParsedChanged += media_ParsedChanged;
myVlcControl.Media = media;
myVlcControl.Play();
this.MediaState = MTC_Player.MediaState.Playing;
}
}
public string SaveStreamToMediaService(Stream stream, string suffix, string extension, string mimeType)
{
var saveName = string.Format(@"{0}_{1}.{2}", DateTime.Now.ToString("yyyyMMddHHmmssfffffff"), suffix, extension);
var mediaBase = new MediaBase
{
FileName = saveName,
FileSize = stream.Length,
MediaOwner = _applicationId,
Title = Path.GetFileNameWithoutExtension(saveName),
FileType = FileType.Image
};
var guid = _mediaStoreClient.SaveFile(_applicationId, null, saveName, stream.Length, mediaBase, stream);
return string.Format(@"http://m.{0}.com/File/{1}?mimeType={2}", _mediaServiceEnvironment, guid, mimeType);
}
private CasparItem _getItem(MediaBase media, VideoLayer videolayer, long seek)
{
if (media != null && media.MediaType == TMediaType.Movie)
{
CasparItem item = new CasparItem(string.Empty);
item.Clipname = $"\"{(media is ServerMedia ? Path.GetFileNameWithoutExtension(media.FileName) : media.FullPath)}\"";
item.ChannelLayout = ChannelLayout.Stereo;
item.VideoLayer = (int)videolayer;
item.Seek = (int)seek;
item.FieldOrderInverted = media.FieldOrderInverted;
return(item);
}
else
{
return(null);
}
}
private async Task <MediaBase> ParseMediaFromJsonAsync(JObject json, bool checkDownload, List <MediaBase> mediaList = null)
{
string id = json["id"].ToString();
var message = await m_client.GetAsync($"https://api.themoviedb.org/3/tv/{id}/external_ids?api_key=295f15628e2e84110ce9197ae94e652b");
JObject result = JObject.Parse(await message.Content.ReadAsStringAsync());
if (!result.ContainsKey("tvdb_id"))
{
return(null);
}
string tvdbid = result["tvdb_id"].ToString();
if (tvdbid == null || tvdbid == string.Empty)
{
return(null);
}
bool?isAnime = await m_tvdbInfo.IsAnimeAsync(tvdbid);
if (!isAnime.HasValue)
{
return(null);
}
if (isAnime.Value != true)
{
return(null);
}
if (checkDownload && !await m_indexer.DoesShowExistAsync(tvdbid))
{
return(null);
}
string posterPath = json["poster_path"].ToString();
if (posterPath == null || posterPath == string.Empty)
{
return(null);
}
MediaBase media = new MediaBase(json["name"].ToString(), "", m_basePosterURL + json["poster_path"].ToString(), id, tvdbid);
if (mediaList != null)
{
mediaList.Add(media);
}
return(media);
}
public bool Load(MediaBase media, VideoLayer videolayer, long seek, long duration)
{
var channel = _casparChannel;
if (CheckConnected(channel) &&
media != null)
{
CasparItem item = _getItem(media, videolayer, seek);
if (item != null)
{
item.Length = (int)duration;
channel.Load(item);
Event removed;
_visible.TryRemove(videolayer, out removed);
_loadedNext.TryRemove(videolayer, out removed);
Debug.WriteLine("CasparLoad media {0} Layer {1} Seek {2}", media, videolayer, seek);
return(true);
}
}
return(false);
}
public void Play(MediaBase media)
{
if (DesignMode)
{
return;
}
//Initialize a default VlcManager
if (myVlcManager == null)
{
myVlcManager = new VlcManager();
}
InitVlcMediaPlayer();
if (media.Initialize(myVlcManager.VlcClient) == IntPtr.Zero)
{
return;
}
LibVlcMethods.libvlc_media_player_set_media(VlcMediaPlayer, media.VlcMedia);
LibVlcMethods.libvlc_media_player_play(VlcMediaPlayer);
}
void testLocalPhoto2()
{
object textureObj = Resources.Load("test2", typeof(Texture2D));
Texture2D texture = (Texture2D)textureObj;
//texture.anisoLevel = 1;
//texture.filterMode = FilterMode.Bilinear;
//texture.wrapMode = TextureWrapMode.Clamp;
//scale to small size
int aScaleSize = MediaBase.getAScaleSize(texture.width);
TextureScale.Bilinear(texture, texture.width / aScaleSize, texture.height / aScaleSize);
JpegInfo jpi = ExifReader.ReadJpeg(texture.EncodeToJPG(), "Foo");
int angle = 0;
switch (jpi.Orientation)
{
case ExifOrientation.TopLeft:
break;
case ExifOrientation.TopRight:
angle = -90;
break;
case ExifOrientation.BottomLeft:
angle = 90;
break;
case ExifOrientation.BottomRight:
angle = 180;
break;
}
texture = TextureRotate.RotateImage(texture, angle);
Sprite picture = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), Vector2.zero, 1);
PictureLoaded(true, "", picture);
}
private void OnMediaStateChange(MediaBase sender, Vlc.DotNet.Core.VlcEventArgs <Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States> e)
{
if (e.Data == Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Playing)
{
if (!initialized)
{
if (media.Duration.TotalMilliseconds > 0)
{
if (!Autoplay)
{
vlc.Pause();
}
else
{
rect.Visibility = System.Windows.Visibility.Hidden;
}
durationMilliseconds = (float)media.Duration.TotalMilliseconds;
initialized = true;
OnMediaLoaded();
}
else if (media.SubItems.Count > 0)
{
var subItems = media.SubItems;
media.StateChanged -= OnMediaStateChange;
subItems[0].StateChanged += OnMediaStateChange;
media = subItems[0];
vlc.Media = subItems[0];
vlc.Play();
}
else
{
OnMediaFailed();
}
}
}
}
public async Task ProcessMediaAsync(MediaBase media, int season, int episode, bool restore = false)
{
MediaFile file = new MediaFile(media, season, episode);
file.IsProcessing = true;
m_data.AddMedia(file);
if (!await m_database.MediaExistsAsync(media.SearchID, season, episode))
{
m_database.AddMedia(media.SearchID, season, episode);
}
foreach (IMediaService service in m_services)
{
await service.ProcessMediaAsync(file, restore);
while (!file.IsFinishedProcessing)
{
if (file.ShouldStopAllProcessing)
{
Console.WriteLine($"{service.GetType().Name} has stopped all further processing of this media");
return;
}
await Task.Delay(100);
}
}
file.Complete();
file.IsProcessing = false;
m_database.RemoveMedia(media.SearchID, season, episode);
m_localDatabase.AddMedia($"{media.ID}", season, episode, file.FilePath);
var p = new Process();
p.StartInfo = new ProcessStartInfo(file.FilePath)
{
UseShellExecute = true
};
p.Start();
}
private void PlayMedia(MediaBase media)
{
if (media != null)
{
if (myVlcControl.Medias != null && myVlcControl.Medias.Count > 0)
myVlcControl.Medias.Clear();
media.StateChanged -= media_StateChanged;
media.StateChanged += media_StateChanged;
media.ParsedChanged -= media_ParsedChanged;
media.ParsedChanged += media_ParsedChanged;
myVlcControl.Media = media;
myVlcControl.Play();
this.MediaState = MTC_Player.MediaState.Playing;
}
}
public MediaFile(MediaBase media, int season, int episode)
{
Media = media;
Season = season;
Episode = episode;
}
/// <summary>
/// Play the media
/// </summary>
/// <param name="media">Media to play</param>
public void Play(MediaBase media)
{
Media = media;
Play();
}
private bool Encode(IngestDirectory directory, string outFile)
{
Debug.WriteLine(this, "Export encode started");
AddOutputMessage($"Encode started to file {outFile}");
StringBuilder files = new StringBuilder();
int index = 0;
List <string> complexFilterElements = new List <string>();
StringBuilder overlayOutputs = new StringBuilder();
List <MediaExportDescription> exportMedia = _exportMediaList.ToList();
TimeSpan startTimecode = exportMedia.First().StartTC;
bool isXdcamDirectory = directory.Kind == TIngestDirectoryKind.XDCAM;
VideoFormatDescription outputFormatDesc = VideoFormatDescription.Descriptions[isXdcamDirectory || directory.ExportContainerFormat == TMovieContainerFormat.mxf ? TVideoFormat.PAL : directory.ExportVideoFormat];
string scaleFilter = $"scale={outputFormatDesc.ImageSize.Width}:{outputFormatDesc.ImageSize.Height}:interl=-1";
foreach (var e in exportMedia)
{
MediaBase media = e.Media as MediaBase;
if (media != null)
{
files.AppendFormat(System.Globalization.CultureInfo.InvariantCulture, " -ss {0} -t {1} -i \"{2}\"", (e.StartTC - media.TcStart).TotalSeconds, e.Duration.TotalSeconds, media.FullPath);
string videoOutputName = $"[v{index}]";
List <string> itemVideoFilters = new List <string>();
if (media.HasExtraLines)
{
itemVideoFilters.Add("crop=720:576:0:32");
}
itemVideoFilters.Add(media.FormatDescription().IsWideScreen ? "setdar=dar=16/9" : "setdar=dar=4/3");
itemVideoFilters.Add(scaleFilter);
complexFilterElements.Add($"[{index}]{string.Join(",", itemVideoFilters)}{videoOutputName}");
int audioIndex = index;
complexFilterElements.Add(string.Format(System.Globalization.CultureInfo.InvariantCulture, "[{0}]volume={1:F3}dB[a{0}]", audioIndex, e.AudioVolume));
index++;
var logos = e.Logos.ToArray();
for (int i = 0; i < logos.Length; i++)
{
if (logos[i] is MediaBase logo)
{
files.Append($" -i \"{logo.FullPath}\"");
string newOutputName = $"[v{index}]";
complexFilterElements.Add($"{videoOutputName}[{index}]overlay{newOutputName}");
videoOutputName = newOutputName;
index++;
}
}
overlayOutputs.AppendFormat("{0}[a{1}]", videoOutputName, audioIndex);
}
}
if (isXdcamDirectory || directory.ExportContainerFormat == TMovieContainerFormat.mxf)
{
if (MXFVideoExportFormat == TmXFVideoExportFormat.DV25)
{
complexFilterElements.Add(string.Format("{0}concat=n={1}:v=1:a=1[v][p]", string.Join(string.Empty, overlayOutputs), exportMedia.Count));
}
else
{
complexFilterElements.Add(string.Format("{0}concat=n={1}:v=1:a=1[vr][p], [vr]{2}[v]", string.Join(string.Empty, overlayOutputs), exportMedia.Count, D10PadFilter));
}
}
else
{
complexFilterElements.Add(string.Format("{0}concat=n={1}:v=1:a=1[v][p]", string.Join(string.Empty, overlayOutputs), exportMedia.Count));
}
complexFilterElements.Add("[p]apad=pad_len=1024[a]");
string complexFilter = complexFilterElements.Count > 0 ?
string.Format(" -filter_complex \"{0}\"", string.Join(", ", complexFilterElements)) :
string.Empty;
string command = string.Format(System.Globalization.CultureInfo.InvariantCulture,
"{0}{1} -map \"[v]\" -map \"[a]\" {2} -timecode {3}{4} -shortest -f {5} -y \"{6}\"",
//0
files.ToString(),
//1
complexFilter,
//2
isXdcamDirectory || directory.ExportContainerFormat == TMovieContainerFormat.mxf ?
String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0} {1}",
MXFVideoExportFormat == TmXFVideoExportFormat.DV25 ? D10PalDv25
: MXFVideoExportFormat == TmXFVideoExportFormat.IMX30 ? D10PalImx30
: MXFVideoExportFormat == TmXFVideoExportFormat.IMX40 ? D10PalImx40
: D10PalImx50
,
MXFAudioExportFormat == TmXFAudioExportFormat.Channels4Bits24 ? Pcm24Le4Ch
: MXFAudioExportFormat == TmXFAudioExportFormat.Channels4Bits16 ? Pcm16Le4Ch
: Pcm16Le8Ch)
:
directory.ExportParams,
//3
startTimecode.ToSMPTETimecodeString(VideoFormatDescription.Descriptions[Dest.VideoFormat].FrameRate),
//4
isXdcamDirectory || directory.ExportContainerFormat == TMovieContainerFormat.mxf ? $" -metadata creation_time=\"{DateTime.UtcNow.ToString("o")}\"" : string.Empty,
//5
(isXdcamDirectory || directory.ExportContainerFormat == TMovieContainerFormat.mxf) && MXFVideoExportFormat != TmXFVideoExportFormat.DV25 ? "mxf_d10" : directory.ExportContainerFormat.ToString(),
outFile);
if (RunProcess(command))
{
Debug.WriteLine(this, "Export encode succeed");
AddOutputMessage("Encode finished successfully");
return(true);
}
Debug.WriteLine("FFmpeg Encode(): Failed for {0}", outFile);
return(false);
}
private void media_ParsedChanged(MediaBase sender, Vlc.DotNet.Core.VlcEventArgs <int> e)
{
}
internal void Previous()
{
if (!Random)
UpdateMediaList();
else
UpdateRandomMediaList();
VlcMediaCollection collection = Random ? mediaRandomList : mediaList;
MediaBase media;
for (int cpt = 0; cpt < 2; cpt++)
{
media = collection.LastOrDefault(m => m.Status == MediaStates.Played);
if (media != null)
{
if (SelectedMedia != null)
{
if (MediaItems.Contains(SelectedMedia))
SelectedMedia.Status = collection.IndexOf(media) < collection.IndexOf(SelectedMedia) ? MediaStates.NotPlayed : MediaStates.Played;
else
collection.Remove(SelectedMedia);
}
media.Status = MediaStates.Selected;
SelectedMedia = media;
break;
}
if (!Loop)
break;
if (cpt == 0)
collection.
Where(m => m.Status == MediaStates.NotPlayed).ToList().
ForEach(m => m.Status = MediaStates.Played);
}
}
internal void Next()
{
if (!Random)
UpdateMediaList();
else
UpdateRandomMediaList();
VlcMediaCollection collection = Random ? mediaRandomList : mediaList;
if (Loop && SelectedMedia != null && collection.IndexOf(SelectedMedia) == collection.Count - 1)
{
collection.ToList().ForEach(m => m.Status = MediaStates.NotPlayed);
}
MediaBase media = collection.FirstOrDefault(m => m.Status == MediaStates.NotPlayed);
if (media != null)
{
if (SelectedMedia != null)
{
if (SelectedMedia.Status == MediaStates.SelectedButDisabled)
collection.Remove(SelectedMedia);
else
SelectedMedia.Status = MediaStates.Played;
}
media.Status = MediaStates.Selected;
SelectedMedia = media;
}
}
IEnumerator LoadPictureCoroutine(string path)
{
WWW www = new WWW(path);
if (www.size == 0)
{
showlog("size 0");
yield return(new WaitForSeconds(1.0f));
LoadPicture(path);
}
else if (!string.IsNullOrEmpty(www.error))
{
showlog("error");
PictureLoaded(false, null, null);
}
else
{
//ExifLib.JpegInfo jpi = ExifLib.ExifReader.ReadJpeg(www.bytes, "test2.jpg");
//showlog("EXIF: " + jpi.Orientation);
//Texture2D texture = new Texture2D(www.texture.width, www.texture.height, TextureFormat.RGB24, false);
//texture.anisoLevel = 1;
//texture.filterMode = FilterMode.Bilinear;
//texture.wrapMode = TextureWrapMode.Clamp;
//www.LoadImageIntoTexture(texture);
//TextureScale.Bilinear(texture, texture.width / 5, texture.height / 5);
//texture = TextureRotate.RotateImage(texture, -90);
Texture2D texture = new Texture2D(www.texture.width, www.texture.height, TextureFormat.RGB24, false);
texture.anisoLevel = 1;
texture.filterMode = FilterMode.Bilinear;
texture.wrapMode = TextureWrapMode.Clamp;
www.LoadImageIntoTexture(texture);
//scale to small size
int aScaleSize = MediaBase.getAScaleSize(texture.width);
TextureScale.Bilinear(texture, texture.width / aScaleSize, texture.height / aScaleSize);
JpegInfo jpi = ExifReader.ReadJpeg(www.bytes, "Foo");
int angle = 0;
switch (jpi.Orientation)
{
case ExifOrientation.TopLeft:
break;
case ExifOrientation.TopRight:
angle = -90;
break;
case ExifOrientation.BottomLeft:
angle = 90;
break;
case ExifOrientation.BottomRight:
angle = 180;
break;
}
texture = TextureRotate.RotateImage(texture, angle);
Sprite picture = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), Vector2.zero, 1);
PictureLoaded(true, path, picture);
}
}
/// <summary>
/// Close of LibVlc and VlcControls instance
/// </summary>
public static void CloseAll()
{
if (HandleManager != null)
{
var mediaBases = new MediaBase[HandleManager.MediasHandles.Count];
HandleManager.MediasHandles.Keys.CopyTo(mediaBases, 0);
foreach (MediaBase mediaBase in mediaBases)
{
mediaBase.Dispose();
}
if (HandleManager.MediaPlayerHandles != null)
{
var mediaPlayers = new IVlcControl[HandleManager.MediaPlayerHandles.Count];
HandleManager.MediaPlayerHandles.Keys.CopyTo(mediaPlayers, 0);
foreach (IVlcControl mediaPlayerHandle in mediaPlayers)
{
mediaPlayerHandle.Dispose();
}
HandleManager.MediaPlayerHandles.Clear();
}
if (InteropManager != null)
InteropManager.ReleaseInstance.Invoke(HandleManager.LibVlcHandle);
HandleManager.LibVlcHandle = IntPtr.Zero;
}
ErrorHandling = null;
if (InteropManager == null)
return;
InteropManager.Dispose();
InteropManager = null;
IsInitialized = false;
}
/// <summary>
/// Called by <see cref="VlcControl.MOVIES"/> when the media information was parsed.
/// </summary>
/// <param name="sender">Event sending media. </param>
/// <param name="e">VLC event arguments. </param>
private void MediaOnParsedChanged(MediaBase sender, VlcEventArgs<int> e)
{
textBlock.Text = string.Format(
"Duration: {0:00}:{1:00}:{2:00}",
myVlcControl.Media.Duration.Hours,
myVlcControl.Media.Duration.Minutes,
myVlcControl.Media.Duration.Seconds);
sliderVolume.Value = myVlcControl.AudioProperties.Volume;
checkboxMute.IsChecked = myVlcControl.AudioProperties.IsMute;
}
void media_ParsedChanged(MediaBase sender, VlcEventArgs<int> e)
{
this.durationMedia = TimeSpan.Zero;
}
private void media_StateChanged(MediaBase sender, VlcEventArgs<Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States> e)
{
if (e.Data == Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Stopped)
{
this.btn_play.Content = "\uf04b";
}
else if (e.Data == Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Paused)
{
if (this.MediaState == MTC_Player.MediaState.Playing)
{
if (sender.Duration.TotalSeconds - this.durationMedia.TotalSeconds < 1)
{
myVlcControl.Position = 0f;
myVlcControl.Play();
}
else
{
this.btn_play.Content = "\uf04b";
myVlcControl.Stop();
}
}
}
else if (e.Data == Vlc.DotNet.Core.Interops.Signatures.LibVlc.Media.States.Playing)
{
this.btn_play.Content = "\uf04c";
}
}
/// <summary>
/// Plays a media.
/// </summary>
public void Play(MediaBase media)
{
Medias.Play(media);
}
private void MediaOnParsedChanged(MediaBase sender, VlcEventArgs<int> e)
{
alta_txt_curTime.Text = myVlcControl.Media.Duration.Format();
}
private async Task <bool> DoExecute(MediaBase inputMedia)
{
string Params = $"-nostats -i \"{inputMedia.FullPath}\" -ss {MeasureStart} -t {(MeasureDuration == TimeSpan.Zero ? inputMedia.DurationPlay : MeasureDuration)} -filter_complex ebur128=peak=sample -f null -";
return(await RunProcess(Params));
}
/// <summary>
/// Play a media
/// </summary>
public void Play(MediaBase media)
{
Medias.Play(media);
}
void media_ParsedChanged(MediaBase sender, VlcEventArgs <int> e)
{
this.durationMedia = TimeSpan.Zero;
}
/// <summary>
/// Play media argument
/// </summary>
/// <param name="media">Media to play</param>
public void Play(MediaBase media)
{
MediaLibrary.MediaItems.Clear();
MediaLibrary.MediaItems.Add(media);
MediaLibrary.SelectedMedia = media;
Play();
}
private void MediaOnParsedChanged(MediaBase sender, VlcEventArgs <int> e)
{
alta_txt_curTime.Text = myVlcControl.Media.Duration.Format();
}
