public ErrorCode init(AVProperty prop, IMediaInfo input, out IMediaInfo output)
{
output = null;
if (input == null)
{
return ErrorCode.NullReference;
}
if (input.stremType() != StreamType.Audio)
{
return ErrorCode.InvalidStream;
}
if (input.mediaType() == MediaType.WAVE_LPCM)
{
lpcm_ = true;
}
else if (input.mediaType() == MediaType.WAVE_PCM)
{
lpcm_ = false;
}
else
{
return ErrorCode.InvalidStream;
}
output = new WaveInfo(input.getAudioInfo(), input.getDuration());
return ErrorCode.Success;
}
public ErrorCode first(out IMediaInfo info)
{
AudioInfo ai = new AudioInfo();
ai.bitsPerSample = bps_;
ai.channels = channels_;
ai.sampleRate = (UInt16)frequency_;
UInt64 duration = 800000 * length_ / ((UInt64)channels_ * (UInt64)bps_ * (UInt64)frequency_);
info = new WaveInfo(ai, duration);
return ErrorCode.Success;
}
public async Task WatermarkTest(Position position)
{
IMediaInfo inputFile = await MediaInfo.Get(Resources.MkvWithAudio).ConfigureAwait(false);
string outputPath = Path.ChangeExtension(Path.GetTempFileName(), FileExtensions.Mp4);
IVideoStream stream = inputFile.VideoStreams.First()
.SetWatermark(Resources.PngSample, position);
IConversionResult conversionResult = await Conversion.New()
.SetPreset(ConversionPreset.UltraFast)
.AddStream(stream)
.SetOutput(outputPath)
.Start().ConfigureAwait(false);
Assert.True(conversionResult.Success);
Assert.Contains("overlay", conversionResult.Arguments);
Assert.Contains(Resources.PngSample, conversionResult.Arguments);
IMediaInfo mediaInfo = await MediaInfo.Get(outputPath).ConfigureAwait(false);
Assert.Equal(TimeSpan.FromSeconds(9), mediaInfo.Duration);
Assert.Equal("h264", mediaInfo.VideoStreams.First().Format);
Assert.False(mediaInfo.AudioStreams.Any());
}
public async Task ChangeBitrate(int expectedBitrate)
{
IMediaInfo inputFile = await MediaInfo.Get(Resources.Mp3).ConfigureAwait(false);
string outputPath = Path.ChangeExtension(Path.GetTempFileName(), FileExtensions.Mp3);
var audioStream = inputFile.AudioStreams.First();
var bitrate = audioStream.Bitrate;
audioStream.ChangeBitrate(expectedBitrate);
IConversionResult conversionResult = await Conversion.New()
.AddStream(audioStream)
.SetOutput(outputPath)
.Start().ConfigureAwait(false);
Assert.True(conversionResult.Success);
IMediaInfo mediaInfo = await MediaInfo.Get(outputPath).ConfigureAwait(false);
Assert.Equal(expectedBitrate, mediaInfo.AudioStreams.First().Bitrate);
Assert.Equal("mp3", mediaInfo.AudioStreams.First().Format);
Assert.NotEmpty(mediaInfo.AudioStreams);
}
public async Task LoopTest()
{
IMediaInfo inputFile = await MediaInfo.Get(Resources.Mp4).ConfigureAwait(false);
string outputPath = Path.ChangeExtension(Path.GetTempFileName(), FileExtensions.Gif);
IConversionResult conversionResult = await Conversion.New()
.AddStream(inputFile.VideoStreams.First()
.SetLoop(1))
.SetOutput(outputPath)
.Start().ConfigureAwait(false);
Assert.True(conversionResult.Success);
IMediaInfo mediaInfo = await MediaInfo.Get(outputPath).ConfigureAwait(false);
Assert.Equal(TimeSpan.FromSeconds(0), mediaInfo.Duration);
Assert.Equal("gif", mediaInfo.VideoStreams.First().Format);
Assert.Equal("16:9", mediaInfo.VideoStreams.First().Ratio);
Assert.Equal(25, mediaInfo.VideoStreams.First().FrameRate);
Assert.Equal(1280, mediaInfo.VideoStreams.First().Width);
Assert.Equal(720, mediaInfo.VideoStreams.First().Height);
Assert.False(mediaInfo.AudioStreams.Any());
}
public void Start()
{
BaseMediaPlayer mediaPlayer = CreatePlatformMediaPlayer();
if (mediaPlayer != null)
{
// Set-up interface
m_Control = mediaPlayer;
m_Texture = mediaPlayer;
m_Dispose = mediaPlayer;
m_Info = mediaPlayer;
m_Player = mediaPlayer;
if (!s_GlobalStartup)
{
#if UNITY_5
Debug.Log(string.Format("[AVProVideo] Initialising AVPro Video (script v{0} plugin v{1}) on {2}/{3} (MT {4})", Helper.ScriptVersion, mediaPlayer.GetVersion(), SystemInfo.graphicsDeviceName, SystemInfo.graphicsDeviceVersion, SystemInfo.graphicsMultiThreaded));
#else
Debug.Log(string.Format("[AVProVideo] Initialising AVPro Video (script v{0} plugin v{1}) on {2}/{3}", Helper.ScriptVersion, mediaPlayer.GetVersion(), SystemInfo.graphicsDeviceName, SystemInfo.graphicsDeviceVersion));
#endif
s_GlobalStartup = true;
}
// Open?
if (m_AutoOpen)
{
OpenVideoFromFile();
}
SetPlaybackOptions();
if (m_Control != null)
{
StartCoroutine("FinalRenderCapture");
}
}
}
public StreamSelector(IMediaInfo mediaInfo)
{
InitializeComponent();
foreach (var astream in mediaInfo.AudioStreams)
{
RadioButton rb = new RadioButton();
rb.Text = $"{astream.Language} {astream.Channels}ch";
rb.Checked = astream.Default != 0;
rb.Tag = astream;
rb.AutoSize = true;
audioLayout.Controls.Add(rb);
audioRadioButtons.Add(rb);
}
foreach (var sstream in mediaInfo.SubtitleStreams)
{
RadioButton rb = new RadioButton();
rb.Text = $"{sstream.Language} {sstream.Title}";
rb.Checked = sstream.Default != 0;
rb.Tag = sstream;
rb.AutoSize = true;
subtitlesLayout.Controls.Add(rb);
subsRadioButtons.Add(rb);
}
}
public async Task OverwriteFilesTest()
{
string output = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + FileExtensions.Mp4);
IMediaInfo info = await FFmpeg.GetMediaInfo(Resources.MkvWithAudio);
IAudioStream audioStream = info.AudioStreams.First()?.SetCodec(AudioCodec.ac3);
IConversionResult conversionResult = await FFmpeg.Conversions.New()
.AddStream(audioStream)
.SetOutput(output)
.Start();
Assert.Contains("-n ", conversionResult.Arguments);
IConversionResult secondConversionResult = await FFmpeg.Conversions.New()
.AddStream(audioStream)
.SetOverwriteOutput(true)
.SetOutput(output)
.Start();
Assert.Contains(" -y ", secondConversionResult.Arguments);
Assert.DoesNotContain(" -n ", secondConversionResult.Arguments);
}
public async Task <string> ConvertToWebMAsync(
string filename,
string?outfile,
CancellationToken cancellationToken)
{
IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(filename, cancellationToken);
IStream video = mediaInfo.VideoStreams.FirstOrDefault()
.SetCodec(VideoCodec.vp8)
.SetSize(VideoSize.Hd1080);
IAudioStream audio = mediaInfo.AudioStreams.FirstOrDefault()
.SetCodec(AudioCodec.libvorbis);
outfile = outfile ?? Path.Join(Path.GetTempPath(), $"{Guid.NewGuid()}.webm");
IConversion?conversion = FFmpeg.Conversions.New()
.AddStream(video, audio)
.SetOutput(outfile);
await conversion.Start(cancellationToken);
return(outfile);
}
public async Task <string> GeneratePreviewGifAsync(
string filename,
string?outfile,
CancellationToken cancellationToken)
{
IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(filename, cancellationToken);
IVideoStream video = mediaInfo.VideoStreams.FirstOrDefault();
var frames = (video.Duration.TotalSeconds == 0 ? 1 : video.Duration.TotalSeconds) * video.Framerate;
outfile = outfile ?? Path.Join(Path.GetTempPath(), $"{Guid.NewGuid()}.gif");
var totalFrames = 50.0;
var rate = Math.Ceiling(frames / totalFrames / video.Duration.TotalSeconds);
if (rate > video.Duration.TotalSeconds)
{
rate = video.Duration.TotalSeconds;
}
video
.SetFramerate(rate)
.SetCodec(VideoCodec.gif)
.ChangeSpeed(2)
.SetSize(VideoSize.Hd480);
IConversion?conversion = FFmpeg.Conversions.New()
.AddStream(video)
.SetOutput(outfile);
await conversion.Start();
return(outfile);
}
public async Task Info_VideoProperties_True()
{
IMediaInfo info = await MediaInfo.Get(Resources.MKV_Encoded_MultipleTracks);
IVideoTrack videoTrack = info.VideoTracks.FirstOrDefault();
Assert.NotNull(videoTrack);
Assert.Equal(8, videoTrack.BitDepth);
Assert.Equal(28656344, videoTrack.Bitrate);
Assert.Equal("4:2:0", videoTrack.ChromaSubSampling);
Assert.Equal("yuv", videoTrack.ColorSpace.ToLower());
Assert.Equal(1.778, videoTrack.DisplayAspectRatio);
Assert.Equal(60.022, videoTrack.Duration);
Assert.Equal("avc", videoTrack.Format.ToLower());
Assert.Equal("4", videoTrack.FormatLevel);
Assert.Equal("high", videoTrack.FormatProfile.ToLower());
Assert.Equal(3276.232, videoTrack.FrameRate);
Assert.Equal("vfr", videoTrack.FrameRateMode.ToLower());
Assert.Equal("cabac=1 / ref=3 / deblock=1:0:0 / analyse=0x3:0x113 / me=hex / subme=7 / psy=1 / psy_rd=1.00:0.00 / mixed_ref=1 / me_range=16 / chroma_me=1 / trellis=1 / 8x8dct=1 / cqm=0 / deadzone=21,11 / fast_pskip=1 / chroma_qp_offset=-2 / threads=18 / lookahead_threads=3 / sliced_threads=0 / nr=0 / decimate=1 / interlaced=0 / bluray_compat=0 / constrained_intra=0 / bframes=3 / b_pyramid=2 / b_adapt=1 / b_bias=0 / direct=1 / weightb=1 / open_gop=0 / weightp=2 / keyint=250 / keyint_min=23 / scenecut=40 / intra_refresh=0 / rc_lookahead=40 / rc=crf / mbtree=1 / crf=23.0 / qcomp=0.60 / qpmin=0 / qpmax=69 / qpstep=4 / ip_ratio=1.40 / aq=1:1.00", videoTrack.EncodedLibrarySetteings);
Assert.Equal(1920, videoTrack.Width);
Assert.Equal(1080, videoTrack.Height);
Assert.Equal(1, videoTrack.PixelAspectRatio);
Assert.Equal(0, videoTrack.StreamOrder);
}
public async Task SetHashFormat_HashInString_CorrectLenght()
{
string fileExtension = FileExtensions.Txt;
string output = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + fileExtension);
IMediaInfo info = await FFmpeg.GetMediaInfo(Resources.MkvWithAudio);
IVideoStream videoStream = info.VideoStreams.First()?.SetCodec(VideoCodec.copy);
IAudioStream audioStream = info.AudioStreams.First()?.SetCodec(AudioCodec.copy);
IConversionResult conversionResult = await FFmpeg.Conversions.New()
.AddStream(videoStream)
.AddStream(audioStream)
.SetOutputFormat(Format.hash)
.SetHashFormat("SHA512/224")
.SetOutput(output)
.Start();
FileInfo fi = new FileInfo(output);
Assert.Equal(fileExtension, fi.Extension);
Assert.Equal(68L, fi.Length);
}
/// <summary>
/// Loop file infinitely to rtsp server with some default parameters like: -re, -preset ultrafast
/// </summary>
/// <param name="inputFilePath">Path to file</param>
/// <param name="rtspServerUri">Uri of RTSP Server in format: rtsp://127.0.0.1:8554/name</param>
/// <returns>IConversion object</returns>
internal static IConversion SendToRtspServer(string inputFilePath, Uri rtspServerUri)
{
IMediaInfo info = FFmpeg.GetMediaInfo(inputFilePath).GetAwaiter().GetResult();
var streams = new List <IStream>();
foreach (var stream in info.VideoStreams)
{
stream.SetStreamLoop(-1);
stream.UseNativeInputRead(true);
stream.SetCodec(VideoCodec.libx264);
stream.SetFramerate(23.976);
stream.SetBitrate(1024000, 1024000, 1024000);
streams.Add(stream);
}
foreach (var stream in info.AudioStreams)
{
stream.SetStreamLoop(-1);
stream.UseNativeInputRead(true);
stream.SetCodec(AudioCodec.aac);
stream.SetBitrate(192000);
stream.SetBitrate(1024000, 1024000, 1024000);
streams.Add(stream);
}
var conversion = New();
conversion.AddStream(streams);
conversion.SetPixelFormat(PixelFormat.yuv420p);
conversion.SetPreset(ConversionPreset.UltraFast);
conversion.SetOutputFormat(Format.rtsp);
conversion.SetOutput(rtspServerUri.OriginalString);
return(conversion);
}
public async Task <ActionResult <IList <UploadResult> > > PostFile(
[FromForm] IEnumerable <IFormFile> files)
{
var maxAllowedFiles = 1;
long maxFileSize = 1024 * 1024 * 15;
var filesProcessed = 0;
var resourcePath = new Uri($"{Request.Scheme}://{Request.Host}/");
IList <UploadResult> uploadResults = new List <UploadResult>();
foreach (var file in files)
{
logger.LogInformation($"Processing upload of file: {file.FileName}, content: {file.ContentType}");
var uploadResult = new UploadResult();
string trustedFileNameForFileStorage;
var untrustedFileName = file.FileName;
uploadResult.FileName = untrustedFileName;
var trustedFileNameForDisplay =
WebUtility.HtmlEncode(untrustedFileName);
if (filesProcessed < maxAllowedFiles)
{
if (file.Length == 0)
{
logger.LogInformation("{FileName} length is 0",
trustedFileNameForDisplay);
uploadResult.ErrorCode = 1;
}
else if (file.Length > maxFileSize)
{
logger.LogInformation("{FileName} of {Length} bytes is " +
"larger than the limit of {Limit} bytes",
trustedFileNameForDisplay, file.Length, maxFileSize);
uploadResult.ErrorCode = 2;
}
else
{
try
{
trustedFileNameForFileStorage = Path.GetRandomFileName();
var temppath = Path.Combine(Path.GetTempPath()
, "unsafe_uploads",
trustedFileNameForFileStorage);
Directory.CreateDirectory(Path.GetDirectoryName(temppath));
using MemoryStream ms = new();
await file.CopyToAsync(ms);
await System.IO.File.WriteAllBytesAsync(temppath, ms.ToArray());
logger.LogInformation("{FileName} saved at {Path}",
trustedFileNameForDisplay, temppath);
logger.LogInformation($"Beginning Transcode");
//transcode the uploaded video file into webm - vp9
IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(temppath);
string output = Path.Combine(Environment.CurrentDirectory, @"wwwroot\videos", Path.ChangeExtension(Path.GetFileName(temppath), "webm"));
Directory.CreateDirectory(Path.GetDirectoryName(output));
logger.LogInformation($"output path: {output}");
IStream videoStream = mediaInfo.VideoStreams.FirstOrDefault()?.SetCodec(VideoCodec.vp9);
IStream audioStream = mediaInfo.AudioStreams.FirstOrDefault()?.SetCodec(AudioCodec.libvorbis);
logger.LogInformation($"video codec: {videoStream.Codec}");
var result = FFmpeg.Conversions.New().AddStream(videoStream, audioStream).SetOutput(output).AddParameter("-vf scale=720:-1");
/*only use hardware acceleration in prod, i think it acutally takes longer. */
//TODO:configuration file for hardware acceleration
#if !DEBUG
//result = result.UseHardwareAcceleration(HardwareAccelerator.auto, Enum.Parse<VideoCodec>(videoStream.Codec), VideoCodec.vp9);
#endif
logger.LogInformation($"{result.Build()}");
var end = await result.Start();
logger.LogInformation($"Transcode duration: {end.Duration}");
logger.LogInformation($"args: {end.Arguments}");
var sql = "Proc_UpsertRuggerVideo";
using (var conn = new SqlConnection(sqlConnectionStringBuilder.ConnectionString))
{
await conn.ExecuteAsync(sql, new { Key = untrustedFileName, filename = Path.GetFileName(output) }, commandType : CommandType.StoredProcedure);
}
uploadResult.Uploaded = true;
uploadResult.StoredFileName = Path.GetFileName(output);
}
catch (IOException ex)
{
logger.LogError("{FileName} error on upload: {Message}",
trustedFileNameForDisplay, ex.Message);
uploadResult.ErrorCode = 3;
}
}
filesProcessed++;
}
else
{
logger.LogInformation("{FileName} not uploaded because the " +
"request exceeded the allowed {Count} of files",
trustedFileNameForDisplay, maxAllowedFiles);
uploadResult.ErrorCode = 4;
}
uploadResults.Add(uploadResult);
}
return(new CreatedResult(resourcePath, uploadResults));
}
public async Task Mp4PropertiesTest()
{
IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(Resources.BunnyMp4);
Assert.True(mediaInfo.Streams.Any());
}
private void OnInspectorGUI_MediaInfo()
{
MediaPlayer media = (this.target) as MediaPlayer;
IMediaInfo info = media.Info;
IMediaControl control = media.Control;
ITextTracks textTracks = media.TextTracks;
IAudioTracks audioTracks = media.AudioTracks;
IVideoTracks videoTracks = media.VideoTracks;
if (info != null)
{
if (!info.HasVideo() && !info.HasAudio()) // && !info.HasText())
{
GUILayout.Label("No media loaded");
}
else
{
if (info.HasVideo())
{
GUILayout.BeginHorizontal();
{
string dimensionText = string.Format("{0}x{1}@{2:0.##}", info.GetVideoWidth(), info.GetVideoHeight(), info.GetVideoFrameRate());
GUILayout.Label(dimensionText);
GUILayout.FlexibleSpace();
string rateText = "0.00";
if (media.Info != null)
{
rateText = media.Info.GetVideoDisplayRate().ToString("F2");
}
GUILayout.Label(rateText + "FPS");
}
GUILayout.EndHorizontal();
EditorGUILayout.Space();
}
if (info.HasVideo())
{
VideoTracks tracks = videoTracks.GetVideoTracks();
if (tracks.Count > 0)
{
GUILayout.Label("Video Tracks: " + tracks.Count);
foreach (VideoTrack track in tracks)
{
bool isActiveTrack = (track == videoTracks.GetActiveVideoTrack());
GUI.color = isActiveTrack?Color.green:Color.white;
{
if (GUILayout.Button(track.DisplayName))
{
if (isActiveTrack)
{
videoTracks.SetActiveVideoTrack(null);
}
else
{
videoTracks.SetActiveVideoTrack(track);
}
}
}
}
GUI.color = Color.white;
EditorGUILayout.Space();
}
}
if (info.HasAudio())
{
AudioTracks tracks = audioTracks.GetAudioTracks();
if (tracks.Count > 0)
{
GUILayout.Label("Audio Tracks: " + tracks.Count);
foreach (AudioTrack track in tracks)
{
bool isActiveTrack = (track == audioTracks.GetActiveAudioTrack());
GUI.color = isActiveTrack?Color.green:Color.white;
{
if (GUILayout.Button(track.DisplayName))
{
if (isActiveTrack)
{
audioTracks.SetActiveAudioTrack(null);
}
else
{
audioTracks.SetActiveAudioTrack(track);
}
}
}
}
GUI.color = Color.white;
/*int channelCount = control.GetAudioChannelCount();
* if (channelCount > 0)
* {
* GUILayout.Label("Audio Channels: " + channelCount);
* AudioChannelMaskFlags audioChannels = control.GetAudioChannelMask();
* GUILayout.Label("(" + audioChannels + ")", EditorHelper.IMGUI.GetWordWrappedTextAreaStyle());
* }*/
EditorGUILayout.Space();
}
}
{
TextTracks tracks = textTracks.GetTextTracks();
if (tracks.Count > 0)
{
GUILayout.Label("Text Tracks: " + tracks.Count);
foreach (TextTrack track in tracks)
{
bool isActiveTrack = (track == textTracks.GetActiveTextTrack());
GUI.color = isActiveTrack?Color.green:Color.white;
{
if (GUILayout.Button(track.DisplayName))
{
if (isActiveTrack)
{
textTracks.SetActiveTextTrack(null);
}
else
{
textTracks.SetActiveTextTrack(track);
}
}
}
}
GUI.color = Color.white;
if (textTracks.GetActiveTextTrack() != null)
{
string text = string.Empty;
if (textTracks.GetCurrentTextCue() != null)
{
text = textTracks.GetCurrentTextCue().Text;
// Clip the text if it is too long
if (text.Length >= 96)
{
text = string.Format("{0}...({1} chars)", text.Substring(0, 96), text.Length);
}
}
GUILayout.Label(text, EditorHelper.IMGUI.GetWordWrappedTextAreaStyle(), GUILayout.Height(48f));
}
EditorGUILayout.Space();
}
}
}
}
else
{
GUILayout.Label("No media loaded");
}
}
public async Task <IActionResult> GetAvailableMedia(string apiToken)
{
if (!await this.IsAPITokenValid(apiToken))
{
return(new BadRequestObjectResult("UnAuthorized"));
}
var response = new AvailableMediaResponse();
try
{
//Set directory where app should look for FFmpeg
FFmpeg.ExecutablesPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "FFmpeg");
//Get latest version of FFmpeg. It's great idea if you don't know if you had installed FFmpeg (required for getting video file info).
await FFmpeg.GetLatestVersion();
string webRootPath = _env.WebRootPath;
string videoFolderDirectory = "media";
var filePath = Path.Combine(webRootPath, videoFolderDirectory);
var videos = new List <AvailableVideo>();
var rawMediaFiles = System.IO.Directory.GetFiles(filePath);
var videoFileNames = new List <string>();
var imageFileNames = new List <string>();
foreach (var file in rawMediaFiles)
{
if (Path.GetExtension(file).ToLower() == ".mp4")
{
videoFileNames.Add(file);
}
else if (Path.GetExtension(file).ToUpper() == ".APNG" ||
Path.GetExtension(file).ToUpper() == ".BMP" ||
Path.GetExtension(file).ToUpper() == ".JPG" ||
Path.GetExtension(file).ToUpper() == ".JPEG" ||
Path.GetExtension(file).ToUpper() == ".PNG" ||
Path.GetExtension(file).ToUpper() == ".SVG" ||
Path.GetExtension(file).ToUpper() == ".WEBP")
{
imageFileNames.Add(Path.GetFileName(file));
}
}
foreach (var videoFile in videoFileNames)
{
IMediaInfo mediaInfo = await MediaInfo.Get(videoFile);
var videoDuration = mediaInfo.VideoStreams.First().Duration;
videos.Add(new AvailableVideo()
{
Duration = videoDuration,
Filename = Path.GetFileName(videoFile)
});
}
response = new AvailableMediaResponse()
{
AvailableVideos = videos,
AvailableImages = imageFileNames,
MediaScreenShowing = Connector.MediaScreenShowing
};
}
catch (Exception ex)
{
return(new BadRequestObjectResult($"Error on Server: {ex.Message}"));
}
return(new OkObjectResult(response));
}
public static ErrorCode create(IMediaInfo info, out IRenderer renderer)
{
renderer = null;
if (info == null)
{
return ErrorCode.NullReference;
}
if (info.stremType() == StreamType.Audio)
{
switch (info.mediaType())
{
case MediaType.WAVE_PCM:
{
renderer = new AudioRenderer();
return ErrorCode.Success;
}
}
}
return ErrorCode.Unsupported;
}
// TODO: Split into Analyse and Transcode, so the Analysis part doesn't get called when run from Queued
private async Task <TranscodeResult> Transcode(int movieJobId, ITorrentClientTorrent torrent, CancellationToken cancellationToken)
{
var sourcePath = MovieDownloadDirectory(torrent);
var videoFiles = GetVideoFilesInDir(sourcePath);
if (videoFiles == null || videoFiles.Length == 0)
{
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.TranscodingError);
_logger.LogWarning($"{torrent.Name} has no compatible video files.");
return(new TranscodeResult(TranscodeResultEnum.NoVideoFiles));
}
var movie = (await _movieService.GetMoviesAsync()).Where(x => x.Id == movieJobId).FirstOrDefault();
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.AnalysisStarted);
var pendingTranscodingJobs = new List <ITranscodingJob>();
var filesToMove = new List <string>();
// Check if any files need transcoding
foreach (var videoFile in videoFiles)
{
IMediaInfo mediaInfo = null;
_logger.LogInformation($"Analyzing {Path.GetFileName(videoFile)}");
try
{
using (var encoder = new FFMPEGEncoderService(_loggerEnc, _encoderConfiguration, _sofakingConfiguration))
{
mediaInfo = await encoder.GetMediaInfo(videoFile);
}
}
catch (Exception ex) {
_logger.LogError($"{nameof(FFMPEGEncoderService.GetMediaInfo)} failed with: {ex.Message}", ex);
}
if (mediaInfo == null)
{
_logger.LogWarning($"File {Path.GetFileName(videoFile)} returned no {nameof(mediaInfo)}");
continue;
}
var flags = EncodingTargetFlags.None;
try
{
if (!HasAcceptableVideo(mediaInfo))
{
flags |= EncodingTargetFlags.NeedsNewVideo;
}
}
catch (ArgumentException ex)
{
_logger.LogError($"{Path.GetFileName(videoFile)}", ex);
_logger.LogError($"{ex.ParamName}: {ex.Message}");
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.AnalysisVideoFailed);
continue;
}
try
{
if (!HasAcceptableAudio(mediaInfo))
{
flags |= EncodingTargetFlags.NeedsNewAudio;
}
}
catch (ArgumentException ex)
{
_logger.LogError($"{Path.GetFileName(videoFile)}", ex);
_logger.LogError($"{ex.ParamName}: {ex.Message}");
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.AnalysisAudioFailed);
continue;
}
if (movie.Genres.HasFlag(GenreFlags.Animation))
{
flags |= EncodingTargetFlags.VideoIsAnimation;
}
if (flags == EncodingTargetFlags.None)
{
_logger.LogInformation($"Video file {videoFile} doesn't need transcoding, adding to files to move.");
filesToMove.Add(videoFile);
continue;
}
_logger.LogInformation($"Adding {videoFile} to transcoding jobs.");
pendingTranscodingJobs.Add(new TranscodingJob
{
SourceFile = videoFile,
Action = flags,
Duration = mediaInfo.Duration,
CancellationToken = cancellationToken,
Metadata = new Dictionary <FFMPEGMetadataEnum, string> {
{ FFMPEGMetadataEnum.title, movie.Title },
{ FFMPEGMetadataEnum.year, movie.Year.ToString() },
{ FFMPEGMetadataEnum.director, movie.Director },
{ FFMPEGMetadataEnum.description, movie.Description },
{ FFMPEGMetadataEnum.episode_id, movie.EpisodeId },
{ FFMPEGMetadataEnum.IMDBRating, movie.ImdbScore.ToString() },
{ FFMPEGMetadataEnum.genre, movie.Genres.ToString() },
{ FFMPEGMetadataEnum.show, movie.Show }
}
});
}
// No transcoding needed for any video files in the folder
// Using this pendingTranscodingJobsList allows us to return for movies that need no transcoding, so they won't wait for the transcoding to be complete and can be simply copied over to the resulting folder.
if (!pendingTranscodingJobs.Any())
{
_logger.LogInformation($"Transcoding not needed, no pending jobs.");
return(new TranscodeResult(TranscodeResultEnum.TranscodingNotNeeded, filesToMove.ToArray()));
}
// If something else is transcoding, then queue
var tjmem = _transcodingJobs.Any();
var tjdb = (await _movieService.GetMoviesAsync()).Where(x => x.Status == MovieStatusEnum.TranscodingStarted).Any();
if (tjmem || tjdb)
{
_logger.LogInformation($"Queuing {movie.TorrentName}");
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.TranscodingQueued);
return(new TranscodeResult(TranscodeResultEnum.Queued));
}
// Set the a cover image for the first file (the largest = the movie), so it will be attached to the output file.
string coverImageJpg = null;
try
{
coverImageJpg = Path.Combine(_sofakingConfiguration.TempFolder, movie.Id + "-Cover.jpg");
await Download.GetFile(movie.ImageUrl, coverImageJpg);
pendingTranscodingJobs[0].CoverImageJpg = coverImageJpg;
}
catch (Exception ex)
{
coverImageJpg = null;
_logger.LogError($"Could not download a Cover image. {ex.Message}", ex);
}
// Start transcoding by copying our pending tasks into the static global queue
_logger.LogInformation($"Setting movie status to TranscodingStarted.");
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.TranscodingStarted);
foreach (var transcodingJob in pendingTranscodingJobs)
{
int attempts = 0;
bool success = false;
while (attempts <= 10)
{
var id = _transcodingJobs.IsEmpty ? 0 : _transcodingJobs.Select(x => x.Key).Max() + 1;
_logger.LogInformation($"Trying to add transconding job {id} to the global queue");
if (_transcodingJobs.TryAdd(id, transcodingJob))
{
success = true;
break;
}
attempts++;
Thread.Sleep(TimeSpan.FromSeconds(3));
}
if (!success)
{
_logger.LogError($"Couldn't add transcoding job {transcodingJob.SourceFile} to the global queue.");
}
}
// Get the first job from the stack, then drop it when done
_ = Task.Run(async() =>
{
while (_transcodingJobs.Any() && _transcodingJobs.TryGetValue(_transcodingJobs.First().Key, out var transcodingJob))
{
if (_encoderTranscodingInstance != null)
{
continue;
}
try
{
// Do this as the first thing, so no other encoding gets started
_encoderTranscodingInstance = new FFMPEGEncoderService(_loggerEnc, _encoderConfiguration, _sofakingConfiguration);
_logger.LogWarning($"Preparing transcoding of {transcodingJob.SourceFile}");
Action FirstOut = () => {
if (!_transcodingJobs.Any())
{
_logger.LogInformation("No transcoding jobs left to remove");
return;
}
var removed = _transcodingJobs.TryRemove(_transcodingJobs.First().Key, out _);
_logger.LogWarning($"Removing first from the queue, result: {removed}.");
};
// TODO: Use a factory
_encoderTranscodingInstance.OnStart += (object sender, EventArgs e) => {
_logger.LogInformation("Transcoding started");
};
_encoderTranscodingInstance.OnProgress += (object sender, EncodingProgressEventArgs e) => {
_logger.LogDebug($"Transcoding progress: {e.ProgressPercent:0.##}%");
};
_encoderTranscodingInstance.OnError += async(object sender, EncodingErrorEventArgs e) => {
FirstOut();
_encoderTranscodingInstance.Dispose();
_encoderTranscodingInstance = null;
if (_transcodingJobs.Count == 0)
{
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.TranscodingError);
}
_logger.LogInformation($"Transcoding failed: {e.Error}");
};
_encoderTranscodingInstance.OnCancelled += async(object sender, EventArgs e) => {
FirstOut();
_encoderTranscodingInstance.Dispose();
_encoderTranscodingInstance = null;
if (_transcodingJobs.Count == 0)
{
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.TranscodingCancelled);
}
_logger.LogInformation("Transcoding cancelled");
};
_encoderTranscodingInstance.OnSuccess += async(object sender, EncodingSuccessEventArgs e) => {
FirstOut();
_logger.LogWarning($"Adding {e.FinishedFile} to the list of files to move ({filesToMove.Count()})");
filesToMove.Add(e.FinishedFile);
if (_transcodingJobs.Count == 0)
{
_logger.LogWarning("All transcoding done.");
await MoveVideoFilesToFinishedDir(movie, torrent, filesToMove.ToArray(), coverImageJpg);
await MovieDownloadedSuccesfulyAsync(torrent, movie);
}
// Do this as the last thing, so no other encoding gets started
_encoderTranscodingInstance.Kill(); // Note: .Dispose here leads to "Broken pipe" Exception
_encoderTranscodingInstance.CleanTempData();
_encoderTranscodingInstance = null;
};
_logger.LogWarning($"Starting transcoding of {transcodingJob.SourceFile}");
await _encoderTranscodingInstance.StartTranscodingAsync(transcodingJob, cancellationToken);
}
catch (Exception e)
{
if (_transcodingJobs.Any())
{
var removed = _transcodingJobs.TryRemove(_transcodingJobs.First().Key, out _);
_logger.LogWarning($"Removing first from the queue, result: {removed}.");
}
await _movieService.SetMovieStatus(movieJobId, MovieStatusEnum.TranscodingError);
_logger.LogError(e.Message);
_encoderTranscodingInstance.DisposeAndKeepFiles();
_encoderTranscodingInstance = null;
}
}
});
return(new TranscodeResult(TranscodeResultEnum.Transcoding, filesToMove.ToArray()));
}
public UserControlMediaInfoViewer( IMediaInfo mediaInfo, String filename )
{
this._mediaInfo = mediaInfo;
this.InitializeComponent();
this.FileLabel.Content = filename;
}
public ErrorCode init(AVProperty prop, IMediaInfo input, out IMediaInfo output)
{
output = null;
if (input == null)
{
return ErrorCode.NullReference;
}
if (input.stremType() != StreamType.Audio)
{
return ErrorCode.InvalidStream;
}
if (input.mediaType() != MediaType.MPEG10)
{
return ErrorCode.InvalidStream;
}
output = new WaveInfo(input.getAudioInfo(), input.getDuration());
return ErrorCode.Success;
}
public static ErrorCode create(IMediaInfo info, out IFilter decoder)
{
decoder = null;
if (info == null)
{
return ErrorCode.NullReference;
}
if (info.stremType() == StreamType.Audio)
{
switch (info.mediaType())
{
case MediaType.WAVE_LPCM:
case MediaType.WAVE_PCM:
{
decoder = new PCMDecoder();
return ErrorCode.Success;
}
case MediaType.MPEG10:
{
decoder = new M1L2Decoder();
return ErrorCode.Success;
}
}
}
return ErrorCode.Unsupported;
}
public async Task <IVideoMetadata> GetVideoMetadata(string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
IMediaInfo mediaInfo = await MediaInfoPromise;
if (await mediaInfo.Open(fileName) == 0)
{
throw new IOException(string.Format("Failed to open media file: {0}", fileName));
}
VideoMetadata metadata = null;
Exception exception = null;
try
{
metadata = new VideoMetadata
{
GeneralFormat = await mediaInfo.GetStringValue(StreamKind.General, "Format"),
GeneralFormatProfile = await mediaInfo.GetStringValue(StreamKind.General, "Format_Profile"),
GeneralCodecID = await mediaInfo.GetStringValue(StreamKind.General, "CodecID"),
GeneralFileSize = await mediaInfo.GetLongValue(StreamKind.General, "FileSize"),
GeneralDuration = await mediaInfo.GetDurationValue(StreamKind.General, "Duration/String3"),
GeneralOverallBitRate = await mediaInfo.GetIntegerValue(StreamKind.General, "BitRate"),
GeneralEncodedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.General, "Encoded_Date")),
GeneralTaggedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.General, "Tagged_Date")),
VideoStreamsCount = await mediaInfo.GetIntegerValue(StreamKind.Video, "StreamCount"),
VideoFormat = await mediaInfo.GetStringValue(StreamKind.Video, "Format"),
VideoFormatInfo = await mediaInfo.GetStringValue(StreamKind.Video, "Format/Info"),
VideoFormatProfile = await mediaInfo.GetStringValue(StreamKind.Video, "Format_Profile"),
VideoFormatSettingsCABAC = await mediaInfo.GetStringValue(StreamKind.Video, "Format_Settings_CABAC"),
VideoFormatSettingsRefFrames = await mediaInfo.GetIntegerValue(StreamKind.Video, "Format_Settings_RefFrames"),
VideoFormatSettingsGOP = await mediaInfo.GetStringValue(StreamKind.Video, "Format_Settings_GOP"),
VideoCodecID = await mediaInfo.GetStringValue(StreamKind.Video, "CodecID"),
VideoCodecIDInfo = await mediaInfo.GetStringValue(StreamKind.Video, "CodecID/Info"),
VideoDuration = await mediaInfo.GetDurationValue(StreamKind.Video, "Duration/String3"),
VideoBitRateMode = await mediaInfo.GetStringValue(StreamKind.Video, "BitRate_Mode"),
VideoBitRate = await mediaInfo.GetIntegerValue(StreamKind.Video, "BitRate"),
VideoBitRateMinimum = await mediaInfo.GetIntegerValue(StreamKind.Video, "BitRate_Minimum"),
VideoBitRateMaximum = await mediaInfo.GetIntegerValue(StreamKind.Video, "BitRate_Maximum"),
VideoBitRateNominal = await mediaInfo.GetIntegerValue(StreamKind.Video, "BitRate_Nominal"),
VideoWidth = await mediaInfo.GetIntegerValue(StreamKind.Video, "Width"),
VideoHeight = await mediaInfo.GetIntegerValue(StreamKind.Video, "Height"),
VideoDisplayAspectRatio = await mediaInfo.GetStringValue(StreamKind.Video, "DisplayAspectRatio/String"),
VideoFrameRateMode = await mediaInfo.GetStringValue(StreamKind.Video, "FrameRate_Mode"),
VideoFrameRate = await mediaInfo.GetDoubleValue(StreamKind.Video, "FrameRate"),
VideoFrameRateMinimum = await mediaInfo.GetDoubleValue(StreamKind.Video, "FrameRate_Minimum"),
VideoFrameRateMaximum = await mediaInfo.GetDoubleValue(StreamKind.Video, "FrameRate_Maximum"),
VideoFrameRateOriginal = await mediaInfo.GetDoubleValue(StreamKind.Video, "FrameRate_Original"),
VideoColorSpace = await mediaInfo.GetStringValue(StreamKind.Video, "ColorSpace"),
VideoChromaSubsampling = await mediaInfo.GetStringValue(StreamKind.Video, "Colorimetry"),
VideoBitDepth = await mediaInfo.GetIntegerValue(StreamKind.Video, "Resolution"),
VideoScanType = await mediaInfo.GetStringValue(StreamKind.Video, "ScanType"),
VideoBitsPixelByFrame = await mediaInfo.GetDoubleValue(StreamKind.Video, "Bits-(Pixel*Frame)"),
VideoStreamSize = await mediaInfo.GetLongValue(StreamKind.Video, "StreamSize"),
VideoTitle = await mediaInfo.GetStringValue(StreamKind.Video, "Title"),
VideoLanguage = await mediaInfo.GetStringValue(StreamKind.Video, "Language"),
VideoEncodedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.Video, "Encoded_Date")),
VideoTaggedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.Video, "Tagged_Date")),
VideoRotation = await mediaInfo.GetDoubleValue(StreamKind.Video, "Rotation"),
AudioStreamsCount = await mediaInfo.GetIntegerValue(StreamKind.Audio, "StreamCount"),
AudioFormat = await mediaInfo.GetStringValue(StreamKind.Audio, "Format"),
AudioFormatInfo = await mediaInfo.GetStringValue(StreamKind.Audio, "Format/Info"),
AudioFormatProfile = await mediaInfo.GetStringValue(StreamKind.Audio, "Format_Profile"),
AudioCodecID = await mediaInfo.GetStringValue(StreamKind.Audio, "CodecID"),
AudioDuration = await mediaInfo.GetDurationValue(StreamKind.Audio, "Duration/String3"),
AudioBitRateMode = await mediaInfo.GetStringValue(StreamKind.Audio, "BitRate_Mode"),
AudioBitRate = await mediaInfo.GetIntegerValue(StreamKind.Audio, "BitRate"),
AudioBitRateMinimum = await mediaInfo.GetIntegerValue(StreamKind.Audio, "BitRate_Minimum"),
AudioBitRateMaximum = await mediaInfo.GetIntegerValue(StreamKind.Audio, "BitRate_Maximum"),
AudioBitRateNominal = await mediaInfo.GetIntegerValue(StreamKind.Audio, "BitRate_Nominal"),
AudioChannels = await mediaInfo.GetIntegerValue(StreamKind.Audio, "Channel(s)"),
AudioChannelPositions = await mediaInfo.GetStringValue(StreamKind.Audio, "ChannelPositions"),
AudioSamplingRate = await mediaInfo.GetIntegerValue(StreamKind.Audio, "SamplingRate"),
AudioCompressionMode = await mediaInfo.GetStringValue(StreamKind.Audio, "Compression_Mode"),
AudioStreamSize = await mediaInfo.GetLongValue(StreamKind.Audio, "StreamSize"),
AudioTitle = await mediaInfo.GetStringValue(StreamKind.Audio, "Title"),
AudioLanguage = await mediaInfo.GetStringValue(StreamKind.Audio, "Language"),
AudioEncodedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.Audio, "Encoded_Date")),
AudioTaggedDate = FixDateTime(await mediaInfo.GetDateValue(StreamKind.Audio, "Tagged_Date"))
};
}
catch (Exception e)
{
exception = e;
}
await mediaInfo.Close();
if (exception != null)
{
throw new ApplicationException(string.Format("Failed to receive metadata for file {0}", fileName), exception);
}
return(metadata);
}
public static XmlDocument CreateMediaInfoXMLLog(string filePath, IEnumerable <IBlockConsumer> blockConsumers)
{
XmlDocument xmlDoc = new XmlDocument();
XmlNode node, subNode;
IMediaInfo mediaInfo = CreateMediaInfoInstance();
mediaInfo.Open(filePath);
node = xmlDoc.AppendChild(xmlDoc.CreateElement("File"));
subNode = node.AppendChild(xmlDoc.CreateElement("Hashes"));
AppendLeaf(xmlDoc, subNode, "Size", (new FileInfo(filePath)).Length.ToString(), null);
if (blockConsumers != null)
{
foreach (HashCalculator hashExecute in blockConsumers.Where(blockConsumer => { return(blockConsumer is HashCalculator); }))
{
AppendLeaf(xmlDoc, subNode, hashExecute.Name, BaseConverter.ToString(hashExecute.HashObj.Hash), null);
if (hashExecute.HashObj is Ed2k)
{
Ed2k ed2k = (Ed2k)hashExecute.HashObj;
if (!ed2k.BlueIsRed)
{
AppendLeaf(xmlDoc, subNode, "Ed2k_Alt", BaseConverter.ToString(ed2k.BlueHash), null);
}
}
}
}
int streamCount, entryCount;
string name, text, measure;
foreach (eStreamType streamKind in Enum.GetValues(typeof(eStreamType)))
{
streamCount = mediaInfo.Count_Get(streamKind);
for (int i = 0; i < streamCount; i++)
{
entryCount = mediaInfo.Count_Get(streamKind, i);
subNode = node.AppendChild(xmlDoc.CreateElement(streamKind.ToString()));
for (int j = 0; j < entryCount; j++)
{
name = mediaInfo.Get(streamKind, i, j, eInfoType.Name).Replace("/", "-").Replace("(", "").Replace(")", "");
if (name.Equals("Chapters_Pos_End") || name.Equals("Chapters_Pos_Begin") || name.Contains("-String"))
{
continue;
}
if (name.Equals("Bits-Pixel*Frame"))
{
name = "BitsPerPixel";
}
text = mediaInfo.Get(streamKind, i, j, eInfoType.Text);
measure = mediaInfo.Get(streamKind, i, j, eInfoType.Measure).Trim();
if (name.IndexOfAny(new char[] { ')', ':' }) < 0 && !String.IsNullOrEmpty(text))
{
AppendLeaf(xmlDoc, subNode, name, text, String.IsNullOrEmpty(measure) ? null : new string[, ] {
{ "Unit", measure }
});
}
else
{
//Debug.Print(name + " " + text + " " + measure);
}
}
if (streamKind == eStreamType.Menu)
{
int indexStart;
int indexEnd;
XmlNode chapterNode;
if (int.TryParse(mediaInfo.Get(streamKind, i, "Chapters_Pos_Begin"), out indexStart) && int.TryParse(mediaInfo.Get(streamKind, i, "Chapters_Pos_End"), out indexEnd))
{
chapterNode = subNode.AppendChild(xmlDoc.CreateElement("Chapters"));
for (; indexStart < indexEnd; indexStart++)
{
AppendLeaf(xmlDoc, chapterNode, "Chapter", mediaInfo.Get(streamKind, i, indexStart, eInfoType.Text), new string[, ] {
{ "TimeStamp", mediaInfo.Get(streamKind, i, indexStart, eInfoType.Name) }
});
}
}
}
}
}
mediaInfo.Close();
return(xmlDoc);
}
void OnGUI()
{
if (Event.current.type == EventType.Layout)
{
SetGuiPositionFromVideoIndex(_debugOverlayCount++);
}
if (_mediaPlayer != null && _mediaPlayer.Info != null)
{
IMediaInfo info = _mediaPlayer.Info;
IMediaControl control = _mediaPlayer.Control;
IMediaProducer textureProducer = _mediaPlayer.TextureProducer;
GUI.depth = _guiDepth;
GUI.matrix = Matrix4x4.TRS(new Vector3(m_GuiPositionX, 10f, 0f), Quaternion.identity, new Vector3(_displaySize, _displaySize, 1.0f));
GUILayout.BeginVertical("box", GUILayout.MaxWidth(s_GuiWidth));
GUILayout.Label(System.IO.Path.GetFileName(_mediaPlayer.m_VideoPath));
GUILayout.Label("Dimensions: " + info.GetVideoWidth() + "x" + info.GetVideoHeight() + "@" + info.GetVideoFrameRate().ToString("F2"));
GUILayout.Label("Time: " + (control.GetCurrentTimeMs() * 0.001f).ToString("F1") + "s / " + (info.GetDurationMs() * 0.001f).ToString("F1") + "s");
GUILayout.Label("Rate: " + info.GetVideoDisplayRate().ToString("F2") + "Hz");
if (_mediaPlayer.m_Resample && _mediaPlayer.FrameResampler != null)
{
Resampler resampler = _mediaPlayer.FrameResampler;
GUILayout.BeginVertical();
GUILayout.Label("Resampler Info:");
GUILayout.Label("Resampler timestamp: " + resampler.TextureTimeStamp);
GUILayout.Label("Resampler frames dropped: " + resampler.DroppedFrames);
GUILayout.Label("Resampler frame displayed timer: " + resampler.FrameDisplayedTimer);
GUILayout.EndVertical();
}
if (textureProducer != null && textureProducer.GetTexture() != null)
{
#if REAL_ANDROID
// In OES mode we can't display the texture without using a special shader, so just don't display it
if (!_optionsAndroid.useFastOesPath)
#endif
{
// Show texture without and with alpha blending
GUILayout.BeginHorizontal();
Rect r1 = GUILayoutUtility.GetRect(32f, 32f);
GUILayout.Space(8f);
Rect r2 = GUILayoutUtility.GetRect(32f, 32f);
Matrix4x4 prevMatrix = GUI.matrix;
if (textureProducer.RequiresVerticalFlip())
{
GUIUtility.ScaleAroundPivot(new Vector2(1f, -1f), new Vector2(0, r1.y + (r1.height / 2f)));
}
GUI.DrawTexture(r1, textureProducer.GetTexture(), ScaleMode.ScaleToFit, false);
GUI.DrawTexture(r2, textureProducer.GetTexture(), ScaleMode.ScaleToFit, true);
GUI.matrix = prevMatrix;
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
}
if (_displayControls)
{
GUILayout.BeginHorizontal();
if (control.IsPaused())
{
if (GUILayout.Button("Play", GUILayout.Width(50)))
{
control.Play();
}
}
else
{
if (GUILayout.Button("Pause", GUILayout.Width(50)))
{
control.Pause();
}
}
float duration = info.GetDurationMs();
float time = control.GetCurrentTimeMs();
float newTime = GUILayout.HorizontalSlider(time, 0f, duration);
if (newTime != time)
{
control.Seek(newTime);
}
GUILayout.EndHorizontal();
}
#if AVPROVIDEO_DEBUG_DISPLAY_EVENTS
// Dirty code to hack in an event monitor
if (Event.current.type == EventType.Repaint)
{
_mediaPlayer.Events.RemoveListener(OnMediaPlayerEvent);
_mediaPlayer.Events.AddListener(OnMediaPlayerEvent);
UpdateEventLogs();
}
if (_eventLog != null && _eventLog.Count > 0)
{
GUILayout.Label("Recent Events: ");
GUILayout.BeginVertical("box");
int eventIndex = 0;
foreach (string eventString in _eventLog)
{
GUI.color = Color.white;
if (eventIndex == 0)
{
GUI.color = new Color(1f, 1f, 1f, _eventTimer);
}
GUILayout.Label(eventString);
eventIndex++;
}
GUILayout.EndVertical();
GUI.color = Color.white;
}
#endif
GUILayout.EndVertical();
}
}
static async void RunConversion(string inPath, string outPath)
{
//Set directory where app should look for FFmpeg
//FFmpeg.SetExecutablesPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "FFmpeg");
FFmpeg.SetExecutablesPath(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "FFmpeg"));
//Get latest version of FFmpeg. It's great idea if you don't know if you had installed FFmpeg.
FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official);
Queue filesToConvert = new Queue();
DirectoryInfo di = new DirectoryInfo(inPath);
foreach (FileInfo file in di.GetFiles())
{
if (file.Extension == ".mp3")
{
filesToConvert.Enqueue(file);
}
}
await Console.Out.WriteLineAsync($"Find {filesToConvert.Count} files to convert.");
//string filePath = Path.Combine("C:", "samples", "SampleVideo.mp4");
//string inputMp3Path = Path.Combine("E:", "bai1.mp3");
//IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(inputMp3Path);
//while (filesToConvert.(out FileInfo fileToConvert))
foreach (FileInfo fileToConvert in filesToConvert)
{
Console.WriteLine("1");
//Save file to the same location with changed extension
//string outputFileName = Path.ChangeExtension(fileToConvert.FullName, ".mp4");
IMediaInfo mediaInfo = await FFmpeg.GetMediaInfo(fileToConvert.DirectoryName);
//var mediaInfo = await MediaInfo.Get(fileToConvert);
//var videoStream = mediaInfo.VideoStreams.First();
var audioStream = mediaInfo.AudioStreams.First();
audioStream.SetBitrate(8000)
.SetChannels(1)
.SetSampleRate(24000)
.SetCodec(AudioCodec.mp3);
////Change some parameters of video stream
////videoStream
//// Rotate video counter clockwise
//// .Rotate(RotateDegrees.CounterClockwise)
//// Set size to 480p
//// .SetSize(VideoSize.Hd480)
//// Set codec which will be used to encode file.If not set it's set automatically according to output file extension
//// .SetCodec(VideoCodec.H264);
//Create new conversion object
var conversion = FFmpeg.Conversions.New()
//Add audio stream to output file
.AddStream(audioStream)
//Set output file path
.SetOutput(outPath)
//SetOverwriteOutput to overwrite files. It's useful when we already run application before
.SetOverwriteOutput(true)
//Disable multithreading
.UseMultiThread(false)
//Set conversion preset. You have to chose between file size and quality of video and duration of conversion
.SetPreset(ConversionPreset.UltraFast);
//Add log to OnProgress
//conversion.OnProgress += async (sender, args) =>
//{
// //Show all output from FFmpeg to console
// await Console.Out.WriteLineAsync($"[{args.Duration}/{args.TotalLength}][{args.Percent}%] {fileToConvert.Name}");
//};
//Start conversion
conversion.Start();
Console.WriteLine($"Finished converion file [{fileToConvert.Name}]");
}
}
public static extern int GetMediaInfoFromStream(
IRandomAccessStream stream,
out IMediaInfo outMediaInfo);
public ErrorCode init(AVProperty prop, IMediaInfo input)
{
if (input == null)
{
return ErrorCode.NullReference;
}
StreamType st = input.stremType();
if (st != StreamType.Audio)
{
return ErrorCode.InvalidStream;
}
MediaType mt = input.mediaType();
if (mt != MediaType.WAVE_PCM)
{
return ErrorCode.InvalidStream;
}
AudioInfo ai = input.getAudioInfo();
wfx_.cbSize = 0;
wfx_.nChannels = ai.channels;
wfx_.wBitsPerSample = ai.bitsPerSample;
wfx_.nBlockAlign = (UInt16)(ai.channels * ai.bitsPerSample / 8);
wfx_.wFormatTag = 1;
wfx_.nSamplesPerSec = ai.sampleRate;
wfx_.nAvgBytesPerSec = wfx_.nBlockAlign * wfx_.nSamplesPerSec;
return ErrorCode.Success;
}
private static void CreateChaptersMIL(XmlDocument xmlDoc, XmlNode chaptersNode, IMediaInfo mediaInfo)
{
Func <string, string, XmlNode> createNode = (name, value) => {
var n = xmlDoc.CreateElement(name);
if (value != null)
{
n.AppendChild(xmlDoc.CreateTextNode(value));
}
return(n);
};
XmlNode editionEntryNode, chapterAtomNode, chapterDisplayNode;
eStreamType streamKind = eStreamType.Menu;
int streamCount, entryCount;
streamCount = mediaInfo.Count_Get(streamKind);
for (int i = 0; i < streamCount; i++)
{
entryCount = mediaInfo.Count_Get(streamKind, i);
editionEntryNode = chaptersNode.AppendChild(xmlDoc.CreateElement("EditionEntry"));
int indexStart, indexEnd;
if (int.TryParse(mediaInfo.Get(streamKind, i, "Chapters_Pos_Begin"), out indexStart) && int.TryParse(mediaInfo.Get(streamKind, i, "Chapters_Pos_End"), out indexEnd))
{
chapterAtomNode = editionEntryNode.AppendChild(xmlDoc.CreateElement("ChapterAtom"));
for (; indexStart < indexEnd; indexStart++)
{
Func <string, ulong> conv = (str) => {
var timeParts = str.Split(new char[] { ':', '.' }).Select(s => ulong.Parse(s.Trim())).ToArray();
return((((timeParts[0] * 60 + timeParts[1]) * 60 + timeParts[2]) * 1000 + timeParts[3]) * 1000000);
};
var timeStamps = mediaInfo.Get(streamKind, i, indexStart, eInfoType.Name).Split('-');
ulong timestampStart = conv(timeStamps[0].Trim());
ulong timestampEnd;
if (timeStamps.Length > 1)
{
timestampEnd = conv(timeStamps[1].Trim());
}
chapterAtomNode.AppendChild(createNode("ChapterTimeStart", timestampStart.ToString()));
chapterDisplayNode = chapterAtomNode.AppendChild(xmlDoc.CreateElement("ChapterDisplay"));
string languageTitle, language, title;
languageTitle = mediaInfo.Get(streamKind, i, indexStart, eInfoType.Text);
language = languageTitle.Contains(':') ? languageTitle.Substring(0, languageTitle.IndexOf(':')) : null;
title = languageTitle.Substring(language == null ? 0 : language.Length + 1);
chapterDisplayNode.AppendChild(createNode("ChapterString", title));
if (language != null)
{
chapterDisplayNode.AppendChild(createNode("ChapterLanguage", language.Equals("en") ? "eng" : language));
}
}
}
}
}
public static extern int GetMediaInfoFromFilePath(
[MarshalAs(UnmanagedType.LPWStr)] string filePath,
out IMediaInfo outMediaInfo);
public static async Task <List <MusicPlaybackItem> > GetPlaybackItemsFromFilesAsync(IReadOnlyList <IStorageItem> items)
{
var files = new List <StorageFile>();
var added = new List <MusicPlaybackItem>();
// [| (cue file, full file path of missing file) |]
var failedCue = new List <Tuple <StorageFile, string> >();
foreach (var file in await GetAllFiles(items))
{
files.Add(file);
}
var listFiles = PickAndRemoveCueM3uWplFiles(files);
foreach (var cueFile in listFiles.Item1)
{
try
{
var failedFileName = await HandleCueFileOpen(cueFile, files, added);
if (failedFileName != null)
{
failedCue.Add(new Tuple <StorageFile, string>(cueFile, failedFileName));
}
}
catch { }
}
foreach (var m3uFile in listFiles.Item2)
{
await HandleM3uAsync(m3uFile, added);
}
foreach (var wplFile in listFiles.Item3)
{
await HandleWplAsync(wplFile, added);
}
foreach (var file in files)
{
try
{
IMediaInfo info = null;
using (var stream = await file.OpenAsync(FileAccessMode.Read))
{
NativeMethods.GetMediaInfoFromStream(stream, out info);
}
if (info == null)
{
continue;
}
var cue = info.AllProperties["cuesheet"];
if (!string.IsNullOrWhiteSpace(cue))
{
var cueItems = await HandleFileWithCue(file,
CueFile.CreateFromString(cue));
added.AddRange(cueItems);
continue;
}
var prop = await file.GetBasicPropertiesAsync();
var internalEntity = DbMediaFile.FromMediaInfo(info, prop.DateModified);
internalEntity.IsExternal = true;
internalEntity.Path = file.Path;
internalEntity.Id = -65535;
if (string.IsNullOrWhiteSpace(internalEntity.Title) &&
!string.IsNullOrWhiteSpace(internalEntity.Path))
{
internalEntity.Title = Path.GetFileNameWithoutExtension(internalEntity.Path);
}
added.Add(MusicPlaybackItem.CreateFromMediaFile(internalEntity));
}
catch { }
}
if (failedCue.Count > 0)
{
added.AddRange(
await FileOpenFailure.AddFailedFilePath(
failedCue));
}
return(added);
}
public MediaInfo(string filePath)
{
this.mediaInfo = FFmpegProvider.GetMediaInfo();
this.mediaInfo.Open(filePath);
}
public async Task Mp4PropertiesTest()
{
IMediaInfo mediaInfo = await MediaInfo.Get(Resources.BunnyMp4).ConfigureAwait(false);
Assert.True(mediaInfo.Streams.Any());
}
public ErrorCode next(out IMediaInfo info)
{
info = null;
return ErrorCode.NoMoreStreams;
}
private void OnInspectorGUI_Player(MediaPlayer mediaPlayer, ITextureProducer textureSource)
{
EditorGUILayout.BeginVertical(GUI.skin.box);
Rect titleRect = Rect.zero;
// Display filename as title of preview
{
string mediaFileName = string.Empty;
if ((MediaSource)_propMediaSource.enumValueIndex == MediaSource.Path)
{
mediaFileName = mediaPlayer.MediaPath.Path;
}
else if ((MediaSource)_propMediaSource.enumValueIndex == MediaSource.Reference)
{
if (_propMediaReference.objectReferenceValue != null)
{
mediaFileName = ((MediaReference)_propMediaReference.objectReferenceValue).GetCurrentPlatformMediaReference().MediaPath.Path;
}
}
// Display the file name, cropping if necessary
if (!string.IsNullOrEmpty(mediaFileName) &&
(0 > mediaFileName.IndexOfAny(System.IO.Path.GetInvalidPathChars())))
{
string text = System.IO.Path.GetFileName(mediaFileName);
titleRect = GUILayoutUtility.GetRect(GUIContent.none, GUI.skin.label);
// Draw background
GUI.Box(titleRect, GUIContent.none, EditorStyles.toolbarButton);
DrawCenterCroppedLabel(titleRect, text);
}
}
// Toggle preview
if (Event.current.type == EventType.MouseDown && Event.current.button == 0 && Event.current.isMouse)
{
if (titleRect.Contains(Event.current.mousePosition))
{
_queuedToggleShowPreview = true;
}
}
if (_showPreview)
{
Texture texture = EditorGUIUtility.whiteTexture;
float textureRatio = 16f / 9f;
if (_lastTextureRatio > 0f)
{
textureRatio = _lastTextureRatio;
}
if (textureSource != null && textureSource.GetTexture() != null)
{
texture = textureSource.GetTexture();
if (_previewTexture)
{
texture = _previewTexture;
}
_lastTextureRatio = textureRatio = (float)texture.width / (float)texture.height;
}
// Reserve rectangle for texture
//GUILayout.BeginHorizontal(GUILayout.MaxHeight(Screen.height / 2f), GUILayout.ExpandHeight(true));
//GUILayout.FlexibleSpace();
Rect textureRect;
//textureRect = GUILayoutUtility.GetRect(256f, 256f);
if (texture != EditorGUIUtility.whiteTexture)
{
if (_showAlpha)
{
float rectRatio = textureRatio * 2f;
rectRatio = Mathf.Max(1f, rectRatio);
textureRect = GUILayoutUtility.GetAspectRect(rectRatio, GUILayout.ExpandWidth(true));
}
else
{
//textureRatio *= 2f;
float rectRatio = Mathf.Max(1f, textureRatio);
textureRect = GUILayoutUtility.GetAspectRect(rectRatio, GUILayout.ExpandWidth(true), GUILayout.Height(256f));
/*GUIStyle style = new GUIStyle(GUI.skin.box);
* style.stretchHeight = true;
* style.stretchWidth = true;
* style.fixedWidth = 0;
* style.fixedHeight = 0;
* textureRect = GUILayoutUtility.GetRect(Screen.width, Screen.width, 128f, Screen.height / 1.2f, style);*/
}
}
else
{
float rectRatio = Mathf.Max(1f, textureRatio);
textureRect = GUILayoutUtility.GetAspectRect(rectRatio, GUILayout.ExpandWidth(true), GUILayout.Height(256f));
}
if (textureRect.height > (Screen.height / 2f))
{
//textureRect.height = Screen.height / 2f;
}
//Debug.Log(textureRect.height + " " + Screen.height);
//GUILayout.FlexibleSpace();
//GUILayout.EndHorizontal();
// Pause / Play toggle on mouse click
if (Event.current.type == EventType.MouseDown && Event.current.button == 0 && Event.current.isMouse)
{
if (textureRect.Contains(Event.current.mousePosition))
{
if (mediaPlayer.Control != null)
{
if (mediaPlayer.Control.IsPaused())
{
mediaPlayer.Play();
}
else
{
mediaPlayer.Pause();
}
}
}
}
if (Event.current.type == EventType.Repaint)
{
GUI.color = Color.gray;
EditorGUI.DrawTextureTransparent(textureRect, Texture2D.blackTexture, ScaleMode.StretchToFill);
GUI.color = Color.white;
//EditorGUI.DrawTextureAlpha(textureRect, Texture2D.whiteTexture, ScaleMode.ScaleToFit);
//GUI.color = Color.black;
//GUI.DrawTexture(textureRect, texture, ScaleMode.StretchToFill, false);
//GUI.color = Color.white;
// Draw the texture
Matrix4x4 prevMatrix = GUI.matrix;
if (textureSource != null && textureSource.RequiresVerticalFlip())
{
// GUIUtility.ScaleAroundPivot(new Vector2(1f, -1f), new Vector2(0f, textureRect.y + (textureRect.height / 2f)));
}
if (!GUI.enabled)
{
//GUI.color = Color.black;
//GUI.DrawTexture(textureRect, texture, ScaleMode.ScaleToFit, false);
//GUI.color = Color.white;
}
else
{
if (_showPreview && texture != EditorGUIUtility.whiteTexture)
{
RenderPreview(mediaPlayer);
}
if (!_showAlpha)
{
if (texture != EditorGUIUtility.whiteTexture)
{
// TODO: In Linear mode, this displays the texture too bright, but GUI.DrawTexture displays it correctly
//GL.sRGBWrite = true;
//GUI.DrawTexture(textureRect, rt, ScaleMode.ScaleToFit, false);
if (_previewTexture)
{
EditorGUI.DrawPreviewTexture(textureRect, _previewTexture, _materialIMGUI, ScaleMode.ScaleToFit);
}
//EditorGUI.DrawTextureTransparent(textureRect, rt, ScaleMode.ScaleToFit);
//VideoRender.DrawTexture(textureRect, rt, ScaleMode.ScaleToFit, AlphaPacking.None, _materialPreview);
//GL.sRGBWrite = false;
}
else
{
// Fill with black
//GUI.color = Color.black;
//GUI.DrawTexture(textureRect, texture, ScaleMode.StretchToFill, false);
//GUI.color = Color.white;
}
}
else
{
textureRect.width /= 2f;
//GUI.DrawTexture(textureRect, rt, ScaleMode.ScaleToFit, false);
//GL.sRGBWrite = true;
//VideoRender.DrawTexture(textureRect, rt, ScaleMode.ScaleToFit, AlphaPacking.None, _materialIMGUI);
//GL.sRGBWrite = false;
textureRect.x += textureRect.width;
//EditorGUI.DrawTextureAlpha(textureRect, texture, ScaleMode.ScaleToFit);
}
}
GUI.matrix = prevMatrix;
}
}
IMediaInfo info = mediaPlayer.Info;
IMediaControl control = mediaPlayer.Control;
bool showBrowseMenu = false;
if (true)
{
bool isPlaying = false;
if (control != null)
{
isPlaying = control.IsPlaying();
}
// Slider layout
EditorGUILayout.BeginHorizontal(GUILayout.Height(EditorGUIUtility.singleLineHeight / 2f));
Rect sliderRect = GUILayoutUtility.GetRect(GUIContent.none, GUI.skin.horizontalSlider, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
EditorGUILayout.EndHorizontal();
float currentTime = 0f;
float durationTime = 0.001f;
if (control != null)
{
currentTime = (float)control.GetCurrentTime();
durationTime = (float)info.GetDuration();
if (float.IsNaN(durationTime))
{
durationTime = 0f;
}
}
TimeRange timelineRange = new TimeRange(0.0, 0.001); // A tiny default duration to prevent divide by zero's
if (info != null)
{
timelineRange = Helper.GetTimelineRange(info.GetDuration(), control.GetSeekableTimes());
}
// Slider
{
// Draw buffering
if (control != null && timelineRange.Duration > 0.0 && Event.current.type == EventType.Repaint)
{
GUI.color = new Color(0f, 1f, 0f, 0.25f);
TimeRanges times = control.GetBufferedTimes();
if (timelineRange.Duration > 0.0)
{
for (int i = 0; i < times.Count; i++)
{
Rect bufferedRect = sliderRect;
float startT = Mathf.Clamp01((float)((times[i].StartTime - timelineRange.StartTime) / timelineRange.Duration));
float endT = Mathf.Clamp01((float)((times[i].EndTime - timelineRange.StartTime) / timelineRange.Duration));
bufferedRect.xMin = sliderRect.xMin + sliderRect.width * startT;
bufferedRect.xMax = sliderRect.xMin + sliderRect.width * endT;
bufferedRect.yMin += sliderRect.height * 0.5f;
GUI.DrawTexture(bufferedRect, Texture2D.whiteTexture);
}
}
GUI.color = Color.white;
}
// Timeline slider
{
float newTime = GUI.HorizontalSlider(sliderRect, currentTime, (float)timelineRange.StartTime, (float)timelineRange.EndTime);
if (newTime != currentTime)
{
if (control != null)
{
// NOTE: For unknown reasons the seeks here behave differently to the MediaPlayerUI demo
// When scrubbing (especially with NotchLC) while the video is playing, the frames will not update and a Stalled state will be shown,
// but using the MediaPlayerUI the same scrubbing will updates the frames. Perhaps it's just an execution order issue
control.Seek(newTime);
}
}
}
}
EditorGUILayout.BeginHorizontal();
string timeTotal = "∞";
if (!float.IsInfinity(durationTime))
{
timeTotal = Helper.GetTimeString(durationTime, false);
}
string timeUsed = Helper.GetTimeString(currentTime - (float)timelineRange.StartTime, false);
GUILayout.Label(timeUsed, GUILayout.ExpandWidth(false));
//GUILayout.Label("/", GUILayout.ExpandWidth(false));
GUILayout.FlexibleSpace();
GUILayout.Label(timeTotal, GUILayout.ExpandWidth(false));
EditorGUILayout.EndHorizontal();
// In non-pro we need to make these 3 icon content black as the buttons are light
// and the icons are white by default
if (!EditorGUIUtility.isProSkin)
{
GUI.contentColor = Color.black;
}
EditorGUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
// Play/Pause
{
float maxHeight = GUI.skin.button.CalcHeight(_iconSceneViewAudio, 0f);
if (!isPlaying)
{
GUI.color = Color.green;
if (GUILayout.Button(_iconPlayButton, GUILayout.ExpandWidth(false), GUILayout.Height(maxHeight)))
{
if (control != null)
{
control.Play();
}
else
{
if (mediaPlayer.MediaSource == MediaSource.Path)
{
mediaPlayer.OpenMedia(mediaPlayer.MediaPath.PathType, mediaPlayer.MediaPath.Path, true);
}
else if (mediaPlayer.MediaSource == MediaSource.Reference)
{
mediaPlayer.OpenMedia(mediaPlayer.MediaReference, true);
}
}
}
}
else
{
GUI.color = Color.yellow;
if (GUILayout.Button(_iconPauseButton, GUILayout.ExpandWidth(false), GUILayout.Height(maxHeight)))
{
if (control != null)
{
control.Pause();
}
}
}
GUI.color = Color.white;
}
// Looping
{
if (!_propLoop.boolValue)
{
GUI.color = Color.grey;
}
float maxHeight = GUI.skin.button.CalcHeight(_iconSceneViewAudio, 0f);
//GUIContent icon = new GUIContent("∞");
if (GUILayout.Button(_iconRotateTool, GUILayout.Height(maxHeight)))
{
if (control != null)
{
control.SetLooping(!_propLoop.boolValue);
}
_propLoop.boolValue = !_propLoop.boolValue;
}
GUI.color = Color.white;
}
// Mute & Volume
EditorGUI.BeginDisabledGroup(UnityEditor.EditorUtility.audioMasterMute);
{
if (_propMuted.boolValue)
{
GUI.color = Color.gray;
}
float maxWidth = _iconPlayButton.image.width;
//if (GUILayout.Button("Muted", GUILayout.ExpandWidth(false), GUILayout.Height(EditorGUIUtility.singleLineHeight)))
//string iconName = "d_AudioListener Icon"; // Unity 2019+
if (GUILayout.Button(_iconSceneViewAudio)) //, GUILayout.Width(maxWidth), GUILayout.Height(EditorGUIUtility.singleLineHeight), GUILayout.ExpandHeight(false)))
{
if (control != null)
{
control.MuteAudio(!_propMuted.boolValue);
}
_propMuted.boolValue = !_propMuted.boolValue;
}
GUI.color = Color.white;
}
if (!_propMuted.boolValue)
{
EditorGUI.BeginChangeCheck();
float newVolume = GUILayout.HorizontalSlider(_propVolume.floatValue, 0f, 1f, GUILayout.ExpandWidth(true), GUILayout.MinWidth(64f));
if (EditorGUI.EndChangeCheck())
{
if (control != null)
{
control.SetVolume(newVolume);
}
_propVolume.floatValue = newVolume;
}
}
EditorGUI.EndDisabledGroup();
GUI.contentColor = Color.white;
GUILayout.FlexibleSpace();
if (Event.current.commandName == "ObjectSelectorClosed" &&
EditorGUIUtility.GetObjectPickerControlID() == 200)
{
_queuedLoadMediaRef = (MediaReference)EditorGUIUtility.GetObjectPickerObject();
}
if (GUILayout.Button(_iconProject, GUILayout.ExpandWidth(false)))
{
showBrowseMenu = true;
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
if (showBrowseMenu)
{
RecentMenu.Create(_propMediaPath, _propMediaSource, MediaFileExtensions, true, 200);
}
if (_queuedLoadMediaRef && Event.current.type == EventType.Repaint)
{
//MediaPlayer mediaPlayer = (MediaPlayer)_propMediaPath.serializedObject.targetObject;
if (mediaPlayer)
{
mediaPlayer.OpenMedia(_queuedLoadMediaRef, true);
_queuedLoadMediaRef = null;
}
}
if (_queuedToggleShowPreview)
{
_showPreview = !_showPreview;
_queuedToggleShowPreview = false;
this.Repaint();
}
}
public ErrorCode first(out IMediaInfo info)
{
info = info_;
return ErrorCode.Success;
}
private void OnInspectorGUI_PlayControls(IMediaControl control, IMediaInfo info)
{
GUILayout.Space(8.0f);
// Slider
EditorGUILayout.BeginHorizontal();
bool isPlaying = false;
if (control != null)
{
isPlaying = control.IsPlaying();
}
float currentTime = 0f;
if (control != null)
{
currentTime = (float)control.GetCurrentTime();
}
float durationTime = 0f;
if (info != null)
{
durationTime = (float)info.GetDuration();
if (float.IsNaN(durationTime))
{
durationTime = 0f;
}
}
string timeUsed = Helper.GetTimeString(currentTime, true);
GUILayout.Label(timeUsed, GUILayout.ExpandWidth(false));
float newTime = GUILayout.HorizontalSlider(currentTime, 0f, durationTime, GUILayout.ExpandWidth(true));
if (newTime != currentTime)
{
control.Seek(newTime);
}
string timeTotal = "Infinity";
if (!float.IsInfinity(durationTime))
{
timeTotal = Helper.GetTimeString(durationTime, true);
}
GUILayout.Label(timeTotal, GUILayout.ExpandWidth(false));
EditorGUILayout.EndHorizontal();
// Buttons
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Rewind", GUILayout.ExpandWidth(false)))
{
control.Rewind();
}
if (!isPlaying)
{
GUI.color = Color.green;
if (GUILayout.Button("Play", GUILayout.ExpandWidth(true)))
{
control.Play();
}
}
else
{
GUI.color = Color.yellow;
if (GUILayout.Button("Pause", GUILayout.ExpandWidth(true)))
{
control.Pause();
}
}
GUI.color = Color.white;
EditorGUILayout.EndHorizontal();
}
public MediaInfoProvider(string filePath)
{
infos = new InfoCollection();
Func <string, string, string> nonEmpty = (a, b) => string.IsNullOrEmpty(a) ? b : a;
MIL = IntPtr.Size == 8 ? (IMediaInfo) new MediaInfo_x64() : (IMediaInfo) new MediaInfo_x86();
MIL.Option("Internet", "No");
//if(!MIL.Option("Info_Version").Equals("MediaInfoLib - v0.7.42")) throw new Exception("Mediainfo library version mismatch. Needed: v0.7.42, Used: " + MIL.Option("Info_Version"));
MIL.Open(filePath);
Add(EntryKey.Size, Get("FileSize"), "byte");
Add(EntryKey.Duration, Get("Duration", str => (double.Parse(str, CultureInfo.InvariantCulture) / 1000d).ToString("0.000", CultureInfo.InvariantCulture)), "s");
Add(EntryKey.FileExtension, Get("FileExtension") != null ? Get("FileExtension").ToLower() : null, null);
Add(EntryKey.WritingApp, Get("Encoded_Application"), null);
Add(EntryKey.MuxingApp, Get("Encoded_Library"), null);
double dummy;
StreamType st;
int streamCount;
int[] indeces = new int[3];
Converter <eStreamType, StreamType> streamConverter = a => a == eStreamType.Video ? StreamType.Video : (a == eStreamType.Audio ? StreamType.Audio : (a == eStreamType.Text ? StreamType.Text : (StreamType)(-1)));
foreach (eStreamType streamKind in Enum.GetValues(typeof(eStreamType)))
{
streamCount = MIL.Count_Get(streamKind);
st = streamConverter(streamKind);
if ((int)st == -1)
{
continue;
}
for (int i = 0; i < streamCount; i++)
{
Add(st, i, EntryKey.Size, Get(streamKind, i, "StreamSize"), "byte");
Add(st, i, EntryKey.Title, Get(streamKind, i, "Title"), null);
Add(st, i, EntryKey.Id, Get(streamKind, i, "UniqueID"), null);
Add(st, i, EntryKey.Language, Get(streamKind, i, "Language"), null);
Add(st, i, EntryKey.Duration, Get(streamKind, i, "Duration", str => (double.Parse(str.Split('/')[0], CultureInfo.InvariantCulture) / 1000).ToString("0.000", CultureInfo.InvariantCulture)), "s");
Add(st, i, EntryKey.Bitrate, () => Get(streamKind, i, "BitRate").Split('/').First(e => double.TryParse(e, out dummy)), null);
Add(st, i, EntryKey.CodecId, ((Get(streamKind, i, "Format") + " -- " + nonEmpty(Get(streamKind, i, "Format_Version"), Get(streamKind, i, "CodecID"))).Trim() + " -- " + Get(streamKind, i, "Format_Profile").Split('/')[0]).Trim(), null);
Add(st, i, EntryKey.CodecIdAlt, Get(streamKind, i, "CodecID"), null);
Add(st, i, EntryKey.EncodeSettings, Get(streamKind, i, "Encoded_Library_Settings"), null);
Add(st, i, EntryKey.EncodeLibrary, Get(streamKind, i, "Encoded_Library"), null);
Add(st, i, EntryKey.BitrateMode, Get(streamKind, i, "BitRate_Mode"), null);
switch (streamKind)
{
case eStreamType.Video:
Add(st, i, EntryKey.FrameRate, Get(streamKind, i, "FrameRate").Split('/')[0].Trim(), null);
Add(st, i, EntryKey.MaxFrameRate, Get(streamKind, i, "FrameRate_Maximum"), null);
Add(st, i, EntryKey.MinFrameRate, Get(streamKind, i, "FrameRate_Minimum"), null);
Add(st, i, EntryKey.VFR, Get(streamKind, i, "FrameRate_Mode").Contains("VFR") ? Get(streamKind, i, "FrameRate") : null, null);
Add(st, i, EntryKey.FrameCount, Get(streamKind, i, "FrameCount"), null);
Add(st, i, EntryKey.Width, () => Get(streamKind, i, "Width").Split('/')[0], null);
Add(st, i, EntryKey.ColorBitDepth, Get(streamKind, i, "BitDepth"), null);
Add(st, i, EntryKey.Height, () => Get(streamKind, i, "Height").Split('/')[0], null);
Add(st, i, EntryKey.DAR, Get(streamKind, i, "DisplayAspectRatio"), null);
Add(st, i, EntryKey.PAR, () => double.Parse(Get(streamKind, i, "PixelAspectRatio")) != 1 ? Get(streamKind, i, "PixelAspectRatio") : null, null);
indeces[0]++;
break;
case eStreamType.Audio:
Add(st, i, EntryKey.SamplingRate, Get(streamKind, i, "SamplingRate").Split('/')[0], null);
Add(st, i, EntryKey.SampleCount, Get(streamKind, i, "SamplingCount").Split('/')[0], null);
Add(st, i, EntryKey.ChannelCount, Get(streamKind, i, "Channel(s)").Split('/')[0], null);
indeces[1]++;
break;
case eStreamType.Text:
indeces[2]++;
break;
}
}
}
string milInfo = Get("Format/Extensions") != null?Get("Format/Extensions").ToLower() : "";
//string fileExt = System.IO.Path.GetExtension(filePath).ToLower();
if (milInfo.Contains("asf") && milInfo.Contains("wmv") && milInfo.Contains("wma"))
{
if (indeces[0] == 0 && indeces[1] != 0 && indeces[2] == 0)
{
Add(EntryKey.Extension, "wma", null);
}
else
{
Add(EntryKey.Extension, "wmv", null);
}
}
else if (milInfo.Contains("ts") && milInfo.Contains("m2t"))
{
if (System.IO.Path.GetExtension(filePath).Equals(".ts"))
{
Add(EntryKey.Extension, "ts", null); //Blame worf
}
}
else if (milInfo.Contains("mpeg") && milInfo.Contains("mpg"))
{
if (indeces[0] == 0 || indeces[1] == 0 && indeces[1] != 0)
{
Add(EntryKey.Extension, "sub", null);
}
else
{
Add(EntryKey.Extension, "mpg", null);
}
}
else if ((milInfo.Contains("mp1") && milInfo.Contains("mp2") && milInfo.Contains("mp3")) || milInfo.Contains("wav"))
{
switch (Get(eStreamType.Audio, 0, "Format_Profile"))
{
case "Layer 1": Add(EntryKey.Extension, "mp1", null); break;
case "Layer 2": Add(EntryKey.Extension, "mp2", null); break;
case "Layer 3": Add(EntryKey.Extension, "mp3", null); break;
}
}
else if (milInfo.Contains("mp4") && milInfo.Contains("m4a") && milInfo.Contains("m4v"))
{
/*if(indeces[2] != 0 || (indeces[0] != 0 && indeces[1] != 0)) {
* Add(EntryKey.Extension, "mp4", null);
* } else if(indeces[0] != 0 && indeces[1] == 0) {
* Add(EntryKey.Extension, "m4v", null);
* } else if(indeces[0] == 0 && indeces[1] != 0) {
* Add(EntryKey.Extension, "m4a", null);
* }*/
if (indeces[0] == 0 && indeces[2] == 0 && indeces[1] != 0)
{
Add(EntryKey.Extension, "m4a", null);
}
else if (indeces[0] != 0 && indeces[1] == 0 && indeces[2] == 0)
{
Add(EntryKey.Extension, "m4v", null);
}
else
{
Add(EntryKey.Extension, "mp4", null);
}
}
else if (milInfo.Contains("dts"))
{
milInfo = Get(eStreamType.General, 0, "Audio_Codec_List").ToLower();
if (milInfo.Contains("dts-hd"))
{
Add(EntryKey.Extension, "dtshd", null);
}
else if (milInfo.Contains("truehd"))
{
Add(EntryKey.Extension, "thd", null);
}
else
{
Add(EntryKey.Extension, "dts", null);
}
}
if (this[StreamType.General, 0, EntryKey.Extension] == null)
{
if (milInfo.Contains("rm") || milInfo.Contains("rmvb"))
{
Add(EntryKey.Extension, "rm", null);
}
if (milInfo.Contains("asf") || milInfo.Contains("wmv") /*|| milInfo.Contains("wma")*/)
{
Add(EntryKey.Extension, "wmv", null);
}
if (milInfo.Contains("mov") || milInfo.Contains("qt"))
{
Add(EntryKey.Extension, "mov", null);
}
}
if (this[StreamType.General, 0, EntryKey.Extension] == null)
{
Add(EntryKey.Extension, milInfo.Split(' ')[0], null);
}
}
public void AddMediaReference(IMediaInfo reference)
{
if (reference != null)
{
this.mediaReferences.Add(reference);
}
}
public PlaylistMediaAddedEventArgs(IPlaylist playlist, IMediaInfo mediaInfo, int mediaIndex)
{
Playlist = playlist ?? throw new ArgumentNullException(nameof(playlist));
AddedMedia = mediaInfo ?? throw new ArgumentNullException(nameof(mediaInfo));
MediaIndex = mediaIndex;
}
