protected SubProgram(IProgram program)
{
if (null == program)
throw new ArgumentNullException(nameof(program));
_program = program;
}
public Boolean GetLinkStatus(IProgram program)
{
int linkStatus;
GL.GetProgram(program.ProgramId, GetProgramParameterName.LinkStatus, out linkStatus);
return (Boolean)linkStatus;
}
/// <summary>
/// Creates an instance of an Interpreter. Each of the parameters except program is optional..
/// </summary>
/// <param name="program">The program to execute. If this is null, the empty program is executed.</param>
/// <param name="tape">The tape to use as a memory story. If this is null, a default tape is used.</param>
/// <param name="input">The input source to use. If this is null then Console.In is used.</param>
/// <param name="output">The output source to use. If this is null then Console.Out is used.</param>
public Interpreter(IProgram program, Tape tape = null, TextReader input = null, TextWriter output = null)
{
_program = program;
_tape = tape ?? Tape.Default;
_input = input ?? Console.In;
_output = output ?? Console.Out;
}
public LoggingConfiguration(IProgram program, IOperatingSystem os, IVSServices vsservice)
{
NLog.Config.LoggingConfiguration conf;
string assemblyFolder = program.ExecutingAssemblyDirectory;
try
{
conf = new XmlLoggingConfiguration(Path.Combine(assemblyFolder, "NLog.config"), true);
}
catch (Exception ex)
{
vsservice.ActivityLogError(string.Format(CultureInfo.InvariantCulture, "Error loading nlog.config. {0}", ex));
conf = new NLog.Config.LoggingConfiguration();
}
var fileTarget = conf.FindTargetByName("file") as FileTarget;
if (fileTarget == null)
{
fileTarget = new FileTarget();
conf.AddTarget(Path.GetRandomFileName(), fileTarget);
conf.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, fileTarget));
}
fileTarget.FileName = Path.Combine(os.Environment.GetLocalGitHubApplicationDataPath(), "extension.log");
fileTarget.Layout = layout;
try
{
LogManager.Configuration = conf;
}
catch (Exception ex)
{
vsservice.ActivityLogError(string.Format(CultureInfo.InvariantCulture, "Error configuring the log. {0}", ex));
}
}
public OutputWindow(IProgram program)
{
_program = program;
Width = 512;
Height = 512;
Background = Brushes.Transparent;
var timer = new DispatcherTimer(TimeSpan.FromMilliseconds(50), DispatcherPriority.Render, OnTimer,
Dispatcher);
timer.Start();
}
public AppStartController(AppConfiguration appConfiguration)
{
_application = DependencyResolver.GetImplementation<IProgram> ("IProgram", new object[] { appConfiguration });
_appWidget = new AppStartWidget ();
_appWidget.SetApp (appConfiguration.Name, appConfiguration.Command);
_appWidget.Start += AppWidgetStart;
_appWidget.Stop += AppWidgetStop;
_application.HasExited += Application_HasExited;
_application.HasStarted += Application_HasStarted;
_appName = appConfiguration.Name;
}
//ILogger Log = ServiceRegistration.Get<ILogger>();
public bool DoSomethingWithProgram(IProgram program)
{
Log.Debug("SlimTv Button SlimTvRunSingleEPG was pressed");
if (Main_GUI.Instance != null)
{
Main_GUI.Instance.Title(program.Title);
Main_GUI.Instance.Name(program.Title);
string mycommand = "RUN_EPG_SINGLE//VIEWONLY=TRUE//TITLE//NAME";
Log.Debug("Executing command " + mycommand);
Main_GUI.Instance.Command(mycommand);
}
return true;
}
//ILogger Log = ServiceRegistration.Get<ILogger>();
public bool DoSomethingWithProgram(IProgram program)
{
Log.Debug("SlimTvTvWishListQuickMenu was pressed");
if (Main_GUI.Instance != null)
{
Main_GUI.Instance.Title(program.Title);
Main_GUI.Instance.Name(program.Title);
string mycommand = "TVWISHLIST_QUICKMENU//TITLE//NAME";
Log.Debug("Executing command " + mycommand);
Main_GUI.Instance.Command(mycommand);
}
return true;
}
public IEnumerable<UniformInfo> GetActiveUniforms(IProgram program)
{
var uniforms = new List<UniformInfo>();
var numberOfActiveUniforms = program.GetNumberOfActiveUniforms();
for (var uniformIndex = 0; uniformIndex < numberOfActiveUniforms; uniformIndex++)
{
var uniform = GetActiveUniform(program.ProgramId, uniformIndex);
uniforms.Add(uniform);
}
return uniforms;
}
public PSSession(IDebugger debugger, IProgram program)
{
_program = program;
var initialSessionState = InitialSessionState.CreateDefault();
initialSessionState.Variables.Add(new SessionStateVariableEntry("Debugger", debugger,
"Interface to the Windows debuggers", ScopedItemOptions.Constant));
initialSessionState.Variables.Add(new SessionStateVariableEntry("ShellID", "PSExt", "", ScopedItemOptions.Constant));
var location = Assembly.GetExecutingAssembly().Location;
initialSessionState.ImportPSModule(new []{location });
var formatFile = Path.Combine(Path.GetDirectoryName(location), "PSExtCmdlets.Format.ps1xml");
initialSessionState.Formats.Add(new SessionStateFormatEntry(formatFile));
_host = new DbgPsHost(debugger, program);
_runspace = RunspaceFactory.CreateRunspace(_host, initialSessionState);
}
//ILogger Log = ServiceRegistration.Get<ILogger>();
public bool DoSomethingWithProgram(IProgram program)
{
Log.Debug("SlimTv Button Create TvWish was pressed");
if (Main_GUI.Instance != null)
{
Main_GUI.Instance.Title(program.Title);
Main_GUI.Instance.Name(program.Title);
string mycommand = "NEWTVWISH//TITLE//NAME";
Log.Debug("Executing command " + mycommand);
Main_GUI.Instance.Command(mycommand);
}
return true;
}
public void Create()
{
var openGlResourceFactory = new OpenGlResourceFactory();
var vertexShader = openGlResourceFactory.CreateShader(ShaderType.VertexShader);
vertexShader.SetSource(VertexShaderSource);
vertexShader.Compile();
var fragmentShader = openGlResourceFactory.CreateShader(ShaderType.FragmentShader);
fragmentShader.SetSource(FragmentShaderSource);
fragmentShader.Compile();
_program = openGlResourceFactory.CreateProgram();
_program.Create();
_program.AttachShader(vertexShader);
_program.AttachShader(fragmentShader);
_program.Link();
}
public MainForm()
{
InitializeComponent();
if (File.Exists(@"C:\OSP-P\VOLANTE\IMAGES\LATHE.DLL"))
{
_program = new LatheProgram();
}
else if (File.Exists(@"C:\OSP-P\VOLANTE\IMAGES\MC.DLL"))
{
_program = new MillProgram();
}
else
{
_program = new TestProgram();
}
}
public TerrainShader(IOpenGL33 gl)
{
vertexShader = new VertexShader(gl, GetEmbeddedResourceAsString("VertexShader.vs"));
fragmentShader = new FragmentShader(gl, GetEmbeddedResourceAsString("FragmentShader.fs"));
var p = new ModGL.ObjectModel.Shaders.Program(gl, vertexShader, fragmentShader);
p.BindVertexAttributeLocations(PositionNormalTexCoord.Descriptor);
// Bind output fragment to the specified nme
gl.BindFragDataLocation(p.Handle, 0, "Color");
// Compile program and shaders
p.Compile();
program = p;
// Get the uniforms used by the shader program.
diffuseUniform = p.GetUniform<Vector4fUniform, Vector4f>("DiffuseColor");
modelViewProjection = p.GetUniform<MatrixUniform, Matrix4f>("ModelViewProjection");
viewProjection = p.GetUniform<MatrixUniform, Matrix4f>("ViewProjection");
textureUnitUniform = p.GetUniform<IntUniform, int>("Texture");
}
public ConnectionManager(IProgram program, Rothko.IOperatingSystem os)
{
fileExists = (path) => os.File.Exists(path);
readAllText = (path, encoding) => os.File.ReadAllText(path, encoding);
writeAllText = (path, content) => os.File.WriteAllText(path, content);
fileDelete = (path) => os.File.Delete(path);
dirExists = (path) => os.Directory.Exists(path);
dirCreate = (path) => os.Directory.CreateDirectory(path);
Connections = new ObservableCollection<IConnection>();
cachePath = System.IO.Path.Combine(
os.Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
program.ApplicationName,
cacheFile);
LoadConnectionsFromCache();
Connections.CollectionChanged += RefreshConnections;
}
public CubeShader(IOpenGL30 gl)
{
// Create the vertex shader
vertexShader = new VertexShader(gl, GetEmbeddedResourceAsString("cube.vs"));
// Create the fragmet shader
fragmentShader = new FragmentShader(gl, GetEmbeddedResourceAsString("cube.fs"));
// Create the program for both shaders
var p = new ModGL.ObjectModel.Shaders.Program(gl, vertexShader, fragmentShader);
// Tell the shader what field names to use (taken from the vertex Descriptor)
p.BindVertexAttributeLocations(PositionNormalTexCoord.Descriptor);
// Bind output fragment to the specified nme
gl.BindFragDataLocation(p.Handle, 0, "Color");
// Compile program and shaders
p.Compile();
program = p;
// Get the uniforms used by the shader program.
modelViewProjection = p.GetUniform<MatrixUniform, Matrix4f>("ModelViewProjection");
viewProjection = p.GetUniform<MatrixUniform, Matrix4f>("ViewProjection");
diffuseUniform = p.GetUniform<Vector4fUniform, Vector4f>("DiffuseColor");
}
/// <summary>
/// Initialize the cache.
/// </summary>
internal void Initialize()
{
if (GraphicsConfig.EnableShaderCache && GraphicsConfig.TitleId != null)
{
_cacheManager = new CacheManager(CacheGraphicsApi.OpenGL, CacheHashType.XxHash128, "glsl", GraphicsConfig.TitleId, ShaderCodeGenVersion);
bool isReadOnly = _cacheManager.IsReadOnly;
HashSet <Hash128> invalidEntries = null;
if (isReadOnly)
{
Logger.Warning?.Print(LogClass.Gpu, "Loading shader cache in read-only mode (cache in use by another program!)");
}
else
{
invalidEntries = new HashSet <Hash128>();
}
ReadOnlySpan <Hash128> guestProgramList = _cacheManager.GetGuestProgramList();
using AutoResetEvent progressReportEvent = new AutoResetEvent(false);
_shaderCount = 0;
_totalShaderCount = guestProgramList.Length;
ShaderCacheStateChanged?.Invoke(ShaderCacheState.Start, _shaderCount, _totalShaderCount);
Thread progressReportThread = null;
if (guestProgramList.Length > 0)
{
progressReportThread = new Thread(ReportProgress)
{
Name = "ShaderCache.ProgressReporter",
Priority = ThreadPriority.Lowest,
IsBackground = true
};
progressReportThread.Start(progressReportEvent);
}
// Make sure these are initialized before doing compilation.
Capabilities caps = _context.Capabilities;
int maxTaskCount = Math.Min(Environment.ProcessorCount, 8);
int programIndex = 0;
List <ShaderCompileTask> activeTasks = new List <ShaderCompileTask>();
AutoResetEvent taskDoneEvent = new AutoResetEvent(false);
// This thread dispatches tasks to do shader translation, and creates programs that OpenGL will link in the background.
// The program link status is checked in a non-blocking manner so that multiple shaders can be compiled at once.
while (programIndex < guestProgramList.Length || activeTasks.Count > 0)
{
if (activeTasks.Count < maxTaskCount && programIndex < guestProgramList.Length)
{
// Begin a new shader compilation.
Hash128 key = guestProgramList[programIndex];
byte[] hostProgramBinary = _cacheManager.GetHostProgramByHash(ref key);
bool hasHostCache = hostProgramBinary != null;
IProgram hostProgram = null;
// If the program sources aren't in the cache, compile from saved guest program.
byte[] guestProgram = _cacheManager.GetGuestProgramByHash(ref key);
if (guestProgram == null)
{
Logger.Error?.Print(LogClass.Gpu, $"Ignoring orphan shader hash {key} in cache (is the cache incomplete?)");
// Should not happen, but if someone messed with the cache it's better to catch it.
invalidEntries?.Add(key);
_shaderCount = ++programIndex;
continue;
}
ReadOnlySpan <byte> guestProgramReadOnlySpan = guestProgram;
ReadOnlySpan <GuestShaderCacheEntry> cachedShaderEntries = GuestShaderCacheEntry.Parse(ref guestProgramReadOnlySpan, out GuestShaderCacheHeader fileHeader);
if (cachedShaderEntries[0].Header.Stage == ShaderStage.Compute)
{
Debug.Assert(cachedShaderEntries.Length == 1);
GuestShaderCacheEntry entry = cachedShaderEntries[0];
HostShaderCacheEntry[] hostShaderEntries = null;
// Try loading host shader binary.
if (hasHostCache)
{
hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan);
hostProgramBinary = hostProgramBinarySpan.ToArray();
hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary);
}
ShaderCompileTask task = new ShaderCompileTask(taskDoneEvent);
activeTasks.Add(task);
task.OnCompiled(hostProgram, (bool isHostProgramValid, ShaderCompileTask task) =>
{
ShaderProgram program = null;
ShaderProgramInfo shaderProgramInfo = null;
if (isHostProgramValid)
{
// Reconstruct code holder.
program = new ShaderProgram(entry.Header.Stage, "");
shaderProgramInfo = hostShaderEntries[0].ToShaderProgramInfo();
ShaderCodeHolder shader = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
_cpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shader));
return(true);
}
else
{
// If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again.
Task compileTask = Task.Run(() =>
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
program = Translator.CreateContext(0, gpuAccessor, DefaultFlags | TranslationFlags.Compute).Translate(out shaderProgramInfo);
});
task.OnTask(compileTask, (bool _, ShaderCompileTask task) =>
{
ShaderCodeHolder shader = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest...");
// Compile shader and create program as the shader program binary got invalidated.
shader.HostShader = _context.Renderer.CompileShader(ShaderStage.Compute, shader.Program.Code);
hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader.HostShader }, null);
task.OnCompiled(hostProgram, (bool isNewProgramValid, ShaderCompileTask task) =>
{
// As the host program was invalidated, save the new entry in the cache.
hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), new ShaderCodeHolder[] { shader });
if (!isReadOnly)
{
if (hasHostCache)
{
_cacheManager.ReplaceHostProgram(ref key, hostProgramBinary);
}
else
{
Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)");
_cacheManager.AddHostProgram(ref key, hostProgramBinary);
}
}
_cpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shader));
return(true);
});
return(false); // Not finished: still need to compile the host program.
});
return(false); // Not finished: translating the program.
}
});
}
else
{
Debug.Assert(cachedShaderEntries.Length == Constants.ShaderStages);
ShaderCodeHolder[] shaders = new ShaderCodeHolder[cachedShaderEntries.Length];
List <ShaderProgram> shaderPrograms = new List <ShaderProgram>();
TransformFeedbackDescriptor[] tfd = CacheHelper.ReadTransformFeedbackInformation(ref guestProgramReadOnlySpan, fileHeader);
TranslationFlags flags = DefaultFlags;
if (tfd != null)
{
flags |= TranslationFlags.Feedback;
}
TranslationCounts counts = new TranslationCounts();
HostShaderCacheEntry[] hostShaderEntries = null;
// Try loading host shader binary.
if (hasHostCache)
{
hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan);
hostProgramBinary = hostProgramBinarySpan.ToArray();
hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary);
}
ShaderCompileTask task = new ShaderCompileTask(taskDoneEvent);
activeTasks.Add(task);
GuestShaderCacheEntry[] entries = cachedShaderEntries.ToArray();
task.OnCompiled(hostProgram, (bool isHostProgramValid, ShaderCompileTask task) =>
{
Task compileTask = Task.Run(() =>
{
// Reconstruct code holder.
for (int i = 0; i < entries.Length; i++)
{
GuestShaderCacheEntry entry = entries[i];
if (entry == null)
{
continue;
}
ShaderProgram program;
if (entry.Header.SizeA != 0)
{
ShaderProgramInfo shaderProgramInfo;
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "");
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
TranslatorContext translatorContext = Translator.CreateContext(0, gpuAccessor, flags, counts);
TranslatorContext translatorContext2 = Translator.CreateContext((ulong)entry.Header.Size, gpuAccessor, flags | TranslationFlags.VertexA, counts);
program = translatorContext.Translate(out shaderProgramInfo, translatorContext2);
}
// NOTE: Vertex B comes first in the shader cache.
byte[] code = entry.Code.AsSpan().Slice(0, entry.Header.Size).ToArray();
byte[] code2 = entry.Code.AsSpan().Slice(entry.Header.Size, entry.Header.SizeA).ToArray();
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, code, code2);
}
else
{
ShaderProgramInfo shaderProgramInfo;
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "");
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
program = Translator.CreateContext(0, gpuAccessor, flags, counts).Translate(out shaderProgramInfo);
}
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
}
shaderPrograms.Add(program);
}
});
task.OnTask(compileTask, (bool _, ShaderCompileTask task) =>
{
// If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again.
if (!isHostProgramValid)
{
Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest...");
List <IShader> hostShaders = new List <IShader>();
// Compile shaders and create program as the shader program binary got invalidated.
for (int stage = 0; stage < Constants.ShaderStages; stage++)
{
ShaderProgram program = shaders[stage]?.Program;
if (program == null)
{
continue;
}
IShader hostShader = _context.Renderer.CompileShader(program.Stage, program.Code);
shaders[stage].HostShader = hostShader;
hostShaders.Add(hostShader);
}
hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray(), tfd);
task.OnCompiled(hostProgram, (bool isNewProgramValid, ShaderCompileTask task) =>
{
// As the host program was invalidated, save the new entry in the cache.
hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), shaders);
if (!isReadOnly)
{
if (hasHostCache)
{
_cacheManager.ReplaceHostProgram(ref key, hostProgramBinary);
}
else
{
Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)");
_cacheManager.AddHostProgram(ref key, hostProgramBinary);
}
}
_gpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shaders));
return(true);
});
return(false); // Not finished: still need to compile the host program.
}
else
{
_gpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shaders));
return(true);
}
});
return(false); // Not finished: translating the program.
});
}
_shaderCount = ++programIndex;
}
// Process the queue.
for (int i = 0; i < activeTasks.Count; i++)
{
ShaderCompileTask task = activeTasks[i];
if (task.IsDone())
{
activeTasks.RemoveAt(i--);
}
}
if (activeTasks.Count == maxTaskCount)
{
// Wait for a task to be done, or for 1ms.
// Host shader compilation cannot signal when it is done,
// so the 1ms timeout is required to poll status.
taskDoneEvent.WaitOne(1);
}
}
if (!isReadOnly)
{
// Remove entries that are broken in the cache
_cacheManager.RemoveManifestEntries(invalidEntries);
_cacheManager.FlushToArchive();
_cacheManager.Synchronize();
}
progressReportEvent.Set();
progressReportThread?.Join();
ShaderCacheStateChanged?.Invoke(ShaderCacheState.Loaded, _shaderCount, _totalShaderCount);
Logger.Info?.Print(LogClass.Gpu, $"Shader cache loaded {_shaderCount} entries.");
}
}
public bool DoSomethingWithProgram(IProgram program)
{
return true;
}
private static void HandleLine(string input, params string[] args)
{
if (currentProgram != null) //Check program
{
switch (input)
{
case "exit": //Exit program
case "stop":
case "quit":
//Exit
currentProgram.Exit();
currentProgram = null;
//Clear
Console.Clear();
Console.WriteLine("Welcome to Abide Command Line");
break;
default: currentProgram.OnInput(input, args); break; //Program handle input
}
}
else
{
switch (input) //Handle input
{
case "clear":
Console.Clear();
Console.WriteLine("Welcome to Abide Command Line");
break;
case "help":
Console.WriteLine("Yeah uhh no thanks.");
break;
case "exit":
case "stop":
case "quit":
Program.input = false;
break;
case "open":
Console.WriteLine("Drag map file... (Or type path)");
string filename = Console.ReadLine();
OpenMap(filename);
break;
case "map":
if (selectedMap == null)
{
Console.WriteLine("No selected map."); return;
}
Console.WriteLine($"Selected map is {selectedMap.Name} ({selectedMap.Build})");
Console.WriteLine("Would you like to go to the editor? (Y/n)");
if (Console.ReadKey().Key == ConsoleKey.Y)
{
currentProgram = new MapEditor(selectedMap); currentProgram.Start();
}
break;
default:
Console.WriteLine($"Unknown input: \"{input}\"");
break;
}
}
}
public EnterpriseProbeTask(IProgram program, IHttpClient httpClient)
{
productHeader = program.ProductHeader;
this.httpClient = httpClient;
}
public bool RemoveSchedule(IProgram program)
{
Program indexProgram = program as Program;
if (indexProgram == null)
return false;
if (!CheckConnection(indexProgram.ServerIndex))
return false;
WebResult result;
try
{
result = TvServer(indexProgram.ServerIndex).CancelSchedule(program.ProgramId);
}
catch
{
return false;
}
return result.Result;
}
protected virtual void UpdateProgramStatus(IProgram program)
{
CurrentProgram.SetProgram(program);
}
public bool GetProgram(int programId, out IProgram program)
{
throw new NotImplementedException();
}
public bool GetProgram(int programId, out IProgram program)
{
throw new NotImplementedException();
}
public ProgramEventArgs(IProgram program)
{
Program = program;
}
public abstract Task <AsyncResult <ISchedule> > CreateScheduleAsync(IProgram program, ScheduleRecordingType recordingType);
public abstract Task <bool> RemoveScheduleForProgramAsync(IProgram program, ScheduleRecordingType recordingType);
public abstract bool GetProgram(int programId, out IProgram program);
public abstract Task <AsyncResult <IChannel> > GetChannelAsync(IProgram program);
protected virtual IProgram GetProgram(Mediaportal.TV.Server.TVDatabase.Entities.Program tvProgram, bool includeRecordingStatus = false)
#endif
{
InitGenreMap();
//Convert to IProgram
IProgram prog = tvProgram.ToProgram(includeRecordingStatus);
if (prog == null)
{
return(null);
}
//Map genre color if possible
if (_tvGenres.Count > 0 && !string.IsNullOrEmpty(prog.Genre))
{
var genre = _tvGenres.FirstOrDefault(g => g.Value.Any(e => prog.Genre.Equals(e, StringComparison.InvariantCultureIgnoreCase)));
if (genre.Key != EpgGenre.Unknown)
{
prog.EpgGenreId = (int)genre.Key;
switch (genre.Key)
{
case EpgGenre.Movie:
prog.EpgGenreColor = _epgColorSettings.MovieGenreColor;
break;
case EpgGenre.Series:
prog.EpgGenreColor = _epgColorSettings.SeriesGenreColor;
break;
case EpgGenre.Documentary:
prog.EpgGenreColor = _epgColorSettings.DocumentaryGenreColor;
break;
case EpgGenre.Music:
prog.EpgGenreColor = _epgColorSettings.MusicGenreColor;
break;
case EpgGenre.Kids:
prog.EpgGenreColor = _epgColorSettings.KidsGenreColor;
break;
case EpgGenre.News:
prog.EpgGenreColor = _epgColorSettings.NewsGenreColor;
break;
case EpgGenre.Sport:
prog.EpgGenreColor = _epgColorSettings.SportGenreColor;
break;
case EpgGenre.Special:
prog.EpgGenreColor = _epgColorSettings.SpecialGenreColor;
break;
}
}
}
//If genre is unknown and the program contains series info, mark it as a series genre
if (prog.EpgGenreId == (int)EpgGenre.Unknown &&
(!string.IsNullOrWhiteSpace(tvProgram.SeriesNum) || !string.IsNullOrWhiteSpace(tvProgram.EpisodeNum) || !string.IsNullOrWhiteSpace(tvProgram.EpisodePart)))
{
prog.EpgGenreId = (int)EpgGenre.Series;
prog.EpgGenreColor = _epgColorSettings.SeriesGenreColor;
}
return(prog);
}
protected void ShowProgramActions(IProgram program)
{
if (program == null)
{
return;
}
ILocalization loc = ServiceRegistration.Get <ILocalization>();
_programActions = new ItemsList();
// if program is over already, there is nothing to do.
if (program.EndTime < DateTime.Now)
{
_programActions.Add(new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.ProgramOver]")));
}
else
{
// Check if program is currently running.
bool isRunning = DateTime.Now >= program.StartTime && DateTime.Now <= program.EndTime;
if (isRunning)
{
_programActions.Add(new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.WatchNow]"))
{
Command = new MethodDelegateCommand(() =>
{
IChannel channel;
if (_tvHandler.ProgramInfo.GetChannel(program, out channel))
{
IWorkflowManager workflowManager = ServiceRegistration.Get <IWorkflowManager>();
SlimTvClientModel model = workflowManager.GetModel(SlimTvClientModel.MODEL_ID) as SlimTvClientModel;
if (model != null)
{
model.Tune(channel);
// Always switch to fullscreen
workflowManager.NavigatePush(Consts.WF_STATE_ID_FULLSCREEN_VIDEO);
}
}
})
});
}
if (_tvHandler.ScheduleControl != null)
{
RecordingStatus recordingStatus;
if (_tvHandler.ScheduleControl.GetRecordingStatus(program, out recordingStatus) && recordingStatus != RecordingStatus.None)
{
if (isRunning)
{
_programActions.Add(
new ListItem(Consts.KEY_NAME, loc.ToString("[SlimTvClient.WatchFromBeginning]"))
{
Command = new MethodDelegateCommand(() => _tvHandler.WatchRecordingFromBeginning(program))
});
}
_programActions.Add(
new ListItem(Consts.KEY_NAME, loc.ToString(isRunning ? "[SlimTvClient.StopCurrentRecording]" : "[SlimTvClient.DeleteSchedule]", program.Title))
{
Command = new MethodDelegateCommand(() =>
{
if (_tvHandler.ScheduleControl.RemoveScheduleForProgram(program, ScheduleRecordingType.Once))
{
UpdateRecordingStatus(program, RecordingStatus.None);
}
}
)
});
}
else
{
_programActions.Add(
new ListItem(Consts.KEY_NAME, loc.ToString(isRunning ? "[SlimTvClient.RecordNow]" : "[SlimTvClient.CreateSchedule]"))
{
Command = new MethodDelegateCommand(() =>
{
ISchedule schedule;
bool result;
// "No Program" placeholder
if (program.ProgramId == -1)
{
result = _tvHandler.ScheduleControl.CreateScheduleByTime(new Channel {
ChannelId = program.ChannelId
}, program.StartTime, program.EndTime, out schedule);
}
else
{
result = _tvHandler.ScheduleControl.CreateSchedule(program, ScheduleRecordingType.Once, out schedule);
}
if (result)
{
UpdateRecordingStatus(program, RecordingStatus.Scheduled);
}
}
)
});
}
}
}
// Add list entries for extensions
foreach (KeyValuePair <Guid, TvExtension> programExtension in _programExtensions)
{
TvExtension extension = programExtension.Value;
// First check if this extension applies for the selected program
if (!extension.Extension.IsAvailable(program))
{
continue;
}
_programActions.Add(
new ListItem(Consts.KEY_NAME, loc.ToString(extension.Caption))
{
Command = new MethodDelegateCommand(() => extension.Extension.ProgramAction(program))
});
}
IScreenManager screenManager = ServiceRegistration.Get <IScreenManager>();
screenManager.ShowDialog(_programActionsDialogName);
}
public VertexStreamRL VertexStreamRL(IProgram program)
{
return(bufferRangeRL.VertexStreamRL(program));
}
protected virtual bool UpdateRecordingStatus(IProgram program)
{
return(true);
}
/// <summary>
/// L2 error of some quantity derived from the state vector (e.g.,
/// entropy) with respect to given reference solution. The quadrature
/// is determined from the settings in <see cref="IBMControl"/>
/// </summary>
/// <param name="quantityOfInterest"></param>
/// <param name="referenceSolution"></param>
/// <returns></returns>
public static Query L2Error(Func <StateVector, double> quantityOfInterest, Func <double[], double, double> referenceSolution)
{
return(delegate(IApplication <AppControl> app, double time) {
IProgram <CNSControl> program = app as IProgram <CNSControl>;
if (program == null)
{
throw new Exception();
}
ImmersedSpeciesMap speciesMap = program.SpeciesMap as ImmersedSpeciesMap;
IBMControl control = program.Control as IBMControl;
if (speciesMap == null || control == null)
{
throw new Exception(
"Query is only valid for immersed boundary runs");
}
SpeciesId species = speciesMap.Tracker.GetSpeciesId(control.FluidSpeciesName);
int order = control.LevelSetQuadratureOrder;
CellQuadratureScheme scheme = speciesMap.QuadSchemeHelper.GetVolumeQuadScheme(
species, true, speciesMap.SubGrid.VolumeMask);
var composititeRule = scheme.Compile(program.GridData, order);
IChunkRulePair <QuadRule>[] chunkRulePairs = composititeRule.ToArray();
DGField density = program.WorkingSet.Density;
VectorField <DGField> momentum = program.WorkingSet.Momentum;
DGField energy = program.WorkingSet.Energy;
// Construct dummy field since L2Error is currently only supported
// for Field's; However, _avoid_ a projection.
DGField dummy = new SinglePhaseField(new Basis(program.GridData, 0));
Material material = speciesMap.GetMaterial(double.NaN);
int index = 0;
double value = dummy.LxError(
(ScalarFunctionEx) delegate(int j0, int Len, NodeSet nodes, MultidimensionalArray result) {
MultidimensionalArray input = program.GridData.GlobalNodes.GetValue_Cell(nodes, j0, Len);
Chunk chunk = chunkRulePairs[index].Chunk;
QuadRule rule = chunkRulePairs[index].Rule;
if (chunk.i0 != j0 || chunk.Len != Len)
{
throw new Exception();
}
if (rule.NoOfNodes != nodes.GetLength(0))
{
throw new Exception();
}
MultidimensionalArray rho = MultidimensionalArray.Create(chunk.Len, rule.NoOfNodes);
density.Evaluate(chunk.i0, chunk.Len, nodes, rho);
MultidimensionalArray[] m = new MultidimensionalArray[CompressibleEnvironment.NumberOfDimensions];
for (int d = 0; d < CompressibleEnvironment.NumberOfDimensions; d++)
{
m[d] = MultidimensionalArray.Create(chunk.Len, rule.NoOfNodes);
momentum[d].Evaluate(chunk.i0, chunk.Len, nodes, m[d]);
}
MultidimensionalArray rhoE = MultidimensionalArray.Create(chunk.Len, rule.NoOfNodes);
energy.Evaluate(chunk.i0, chunk.Len, nodes, rhoE);
double[] X = new double[CompressibleEnvironment.NumberOfDimensions];
Vector mVec = new Vector(CompressibleEnvironment.NumberOfDimensions);
for (int i = 0; i < chunk.Len; i++)
{
for (int j = 0; j < rule.NoOfNodes; j++)
{
for (int d = 0; d < CompressibleEnvironment.NumberOfDimensions; d++)
{
X[d] = input[i, j, d];
mVec[d] = m[d][i, j];
}
StateVector state = new StateVector(material, rho[i, j], mVec, rhoE[i, j]);
double qoi = quantityOfInterest(state);
Debug.Assert(
!double.IsNaN(qoi),
"Encountered node with unphysical state"
+ " (not able to determine quantity of interest)");
result[i, j] = qoi - referenceSolution(X, time);
}
}
index++;
},
(X, a, b) => (a - b) * (a - b),
composititeRule);
// No value is NaN, but the results. How can this be?
// => All values around 0, but values in void region are a little
// farther away from the exact solution
// => weights in the void zone sum up to something slightly negative
Debug.Assert(
value >= 0,
"Encountered unphysical norm even though individual values where valid."
+ " This indicates a problem with cut-cell quadrature.");
return Math.Sqrt(value);
});
}
public static async Task <object> Run([HttpTrigger(WebHookType = "genericJson")] HttpRequestMessage req, TraceWriter log)
{
log.Info($"Webhook was triggered!");
string jsonContent = await req.Content.ReadAsStringAsync();
dynamic data = JsonConvert.DeserializeObject(jsonContent);
log.Info(jsonContent);
if (data.channelName == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, new
{
error = "Please pass channelName in the input object"
}));
}
if (data.programName == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, new
{
error = "Please pass programName in the input object"
}));
}
string channelName = data.channelName;
string programName = data.programName;
IProgram program = null;
MediaServicesCredentials amsCredentials = new MediaServicesCredentials();
log.Info($"Using Azure Media Service Rest API Endpoint : {amsCredentials.AmsRestApiEndpoint}");
try
{
AzureAdTokenCredentials tokenCredentials = new AzureAdTokenCredentials(amsCredentials.AmsAadTenantDomain,
new AzureAdClientSymmetricKey(amsCredentials.AmsClientId, amsCredentials.AmsClientSecret),
AzureEnvironments.AzureCloudEnvironment);
AzureAdTokenProvider tokenProvider = new AzureAdTokenProvider(tokenCredentials);
_context = new CloudMediaContext(amsCredentials.AmsRestApiEndpoint, tokenProvider);
log.Info("Context object created.");
var channel = _context.Channels.Where(c => c.Name == channelName).FirstOrDefault();
if (channel == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, new
{
error = string.Format("Channel {0} not found", channelName)
}));
}
program = channel.Programs.Where(p => p.Name.Equals(programName)).FirstOrDefault();
if (program == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, new
{
error = string.Format("Program {0} not found", programName)
}));
}
var asset = program.Asset;
log.Info("Deleting program...");
program.Delete();
log.Info("Program deleted.");
if (data.deleteAsset != null && (bool)data.deleteAsset)
{
log.Info("Deleting asset...");
asset.Delete();
log.Info("Asset deleted.");
}
}
catch (Exception ex)
{
string message = ex.Message + ((ex.InnerException != null) ? Environment.NewLine + MediaServicesHelper.GetErrorMessage(ex) : "");
log.Info($"ERROR: Exception {message}");
return(req.CreateResponse(HttpStatusCode.InternalServerError, new { error = message }));
}
return(req.CreateResponse(HttpStatusCode.OK, new
{
success = true
}));
}
/// <summary>
///
/// </summary>
/// <param name="patch"></param>
public WindowEditSingleProgram(IProgram patch)
{
InitializeComponent();
_patch = patch;
}
public async Task <AsyncResult <IChannel> > GetChannelAsync(IProgram program)
{
return(await GetChannelAsync(program.ChannelId));
}
/// <summary>
///
/// </summary>
/// <param name="clipBoardPatches"></param>
/// <param name="patch1"></param>
/// <param name="overwriteAllowed"></param>
/// <returns></returns>
private bool CheckOverwriteAllowedForPrograms(out IClipBoardPatches clipBoardPatches, IProgram patch1,
bool overwriteAllowed)
{
clipBoardPatches = null;
if (((IBank)(patch1.Parent)).IsWritable &&
(Settings.Default.CopyPaste_OverwriteFilledPrograms || patch1.IsEmptyOrInit))
{
IProgram program = patch1;
clipBoardPatches = PcgClipBoard.Programs[(int)(((IProgramBank)(program.Parent)).BankSynthesisType)];
overwriteAllowed = true;
}
return(overwriteAllowed);
}
public bool GetNextProgram(IChannel channel, out IProgram program)
{
IProgram programNow;
return(GetNowNextProgram(channel, out programNow, out program));
}
public bool GetNextProgram(IChannel channel, out IProgram program)
{
program = null;
Channel indexChannel = channel as Channel;
if (indexChannel == null)
return false;
if (!CheckConnection(indexChannel.ServerIndex))
return false;
IProgram currentProgram;
try
{
if (GetCurrentProgram(channel, out currentProgram))
{
IList<WebProgramDetailed> nextPrograms = TvServer(indexChannel.ServerIndex).GetProgramsDetailedForChannel(channel.ChannelId,
currentProgram.EndTime.AddMinutes(1),
currentProgram.EndTime.AddMinutes(1));
if (nextPrograms != null && nextPrograms.Count > 0)
{
program = new Program(nextPrograms[0], indexChannel.ServerIndex);
return true;
}
}
}
catch (Exception ex)
{
ServiceRegistration.Get<ILogger>().Error(ex.Message);
}
return false;
}
public bool RemoveScheduleForProgram(IProgram program, ScheduleRecordingType recordingType)
{
try
{
CpAction action = GetAction(Consts.ACTION_REMOVE_SCHEDULE_FOR_PROGRAM);
IList<object> inParameters = new List<object> { program.ProgramId, (int)recordingType };
IList<object> outParameters = action.InvokeAction(inParameters);
return (bool)outParameters[0];
}
catch (Exception ex)
{
NotifyException(ex);
return false;
}
}
public AddIn(InteropApplication application, IProgram program, IRibbon ribbon)
{
this.Application = application;
this.Program = program;
this.Ribbon = ribbon;
this.workbookByInteropWorkbook = new Dictionary <InteropWorkbook, Workbook>();
((InteropAppEvents_Event)this.Application).NewWorkbook += async interopWorkbook =>
{
if (!string.IsNullOrWhiteSpace(this.ExistentialAttribute))
{
var customProperties = new CustomProperties(interopWorkbook.CustomDocumentProperties);
if (!customProperties.Exist(this.ExistentialAttribute))
{
return;
}
}
var workbook = this.New(interopWorkbook);
for (var i = 1; i <= interopWorkbook.Worksheets.Count; i++)
{
var interopWorksheet = (InteropWorksheet)interopWorkbook.Worksheets[i];
workbook.New(interopWorksheet);
}
var worksheets = workbook.Worksheets;
await this.Program.OnNew(workbook);
foreach (var worksheet in worksheets)
{
await program.OnNew(worksheet);
}
};
this.Application.WorkbookOpen += async interopWorkbook =>
{
if (!string.IsNullOrWhiteSpace(this.ExistentialAttribute))
{
var customProperties = new CustomProperties(interopWorkbook.CustomDocumentProperties);
if (!customProperties.Exist(this.ExistentialAttribute))
{
return;
}
}
var workbook = this.New(interopWorkbook);
for (var i = 1; i <= interopWorkbook.Worksheets.Count; i++)
{
var interopWorksheet = (InteropWorksheet)interopWorkbook.Worksheets[i];
workbook.New(interopWorksheet);
}
var worksheets = workbook.Worksheets;
await this.Program.OnNew(workbook);
foreach (var worksheet in worksheets)
{
await program.OnNew(worksheet);
}
};
this.Application.WorkbookActivate += interopWorkbook =>
{
if (!string.IsNullOrWhiteSpace(this.ExistentialAttribute))
{
var customProperties = new CustomProperties(interopWorkbook.CustomDocumentProperties);
if (!customProperties.Exist(this.ExistentialAttribute))
{
return;
}
}
if (!this.WorkbookByInteropWorkbook.TryGetValue(interopWorkbook, out var workbook))
{
workbook = this.New(interopWorkbook);
}
workbook.IsActive = true;
};
this.Application.WorkbookDeactivate += wb =>
{
// Could already be gone by the WorkbookBeforeClose event
if (this.WorkbookByInteropWorkbook.TryGetValue(wb, out _))
{
this.WorkbookByInteropWorkbook[wb].IsActive = false;
}
};
void WorkbookBeforeClose(InteropWorkbook interopWorkbook, ref bool cancel)
{
if (this.WorkbookByInteropWorkbook.TryGetValue(interopWorkbook, out var workbook))
{
this.Program.OnClose(workbook, ref cancel);
if (!cancel)
{
this.Close(interopWorkbook);
}
}
}
this.Application.WorkbookBeforeClose += WorkbookBeforeClose;
}
public bool GetRecordingFileOrStream(IProgram program, out string fileOrStream)
{
try
{
CpAction action = GetAction(Consts.ACTION_GET_REC_FILE_OR_STREAM);
IList<object> inParameters = new List<object> { program.ProgramId };
IList<object> outParameters = action.InvokeAction(inParameters);
bool result = (bool)outParameters[0];
fileOrStream = (string)outParameters[1];
return result;
}
catch (Exception ex)
{
NotifyException(ex);
fileOrStream = null;
return false;
}
}
public bool GetChannel(IProgram program, out IChannel channel)
{
channel = null;
Program indexProgram = program as Program;
if (indexProgram == null)
return false;
if (!CheckConnection(indexProgram.ServerIndex))
return false;
try
{
WebChannelBasic tvChannel = TvServer(indexProgram.ServerIndex).GetChannelBasicById(indexProgram.ChannelId);
if (tvChannel != null)
{
channel = new Channel { ChannelId = tvChannel.Id, Name = tvChannel.DisplayName, ServerIndex = indexProgram.ServerIndex };
return true;
}
}
catch (Exception ex)
{
ServiceRegistration.Get<ILogger>().Error(ex.Message);
}
return false;
}
public abstract Task <AsyncResult <RecordingStatus> > GetRecordingStatusAsync(IProgram program);
public bool GetCurrentProgram(IChannel channel, out IProgram program)
{
IProgram programNext;
return(GetNowNextProgram(channel, out program, out programNext));
}
public bool CreateSchedule(IProgram program, ScheduleRecordingType recordingType, out ISchedule schedule)
{
try
{
CpAction action = GetAction(Consts.ACTION_CREATE_SCHEDULE);
IList<object> inParameters = new List<object> { program.ProgramId, (int) recordingType };
IList<object> outParameters = action.InvokeAction(inParameters);
bool result = (bool)outParameters[0];
schedule = result ? (ISchedule)outParameters[1] : null;
return result;
}
catch (Exception ex)
{
NotifyException(ex);
schedule = null;
return false;
}
}
public abstract Task <AsyncResult <string> > GetRecordingFileOrStreamAsync(IProgram program);
public bool GetRecordingStatus(IProgram program, out RecordingStatus recordingStatus)
{
try
{
CpAction action = GetAction(Consts.ACTION_GET_REC_STATUS);
IList<object> inParameters = new List<object> { program.ProgramId };
IList<object> outParameters = action.InvokeAction(inParameters);
bool result = (bool)outParameters[0];
recordingStatus = (RecordingStatus)Enum.Parse(typeof(RecordingStatus), outParameters[1].ToString());
return result;
}
catch (Exception ex)
{
NotifyException(ex);
recordingStatus = RecordingStatus.None;
return false;
}
}
protected override bool UpdateRecordingStatus(IProgram program, RecordingStatus newStatus)
{
bool changed = base.UpdateRecordingStatus(program, newStatus);
return(changed && UpdateRecordingStatus(program));
}
public bool CreateSchedule(IProgram program)
{
Program indexProgram = program as Program;
if (indexProgram == null)
return false;
if (!CheckConnection(indexProgram.ServerIndex))
return false;
WebResult result;
try
{
result = TvServer(indexProgram.ServerIndex).AddSchedule(program.ChannelId, program.Title, program.StartTime,
program.EndTime, WebScheduleType.Once);
}
catch
{
return false;
}
return result.Result;
}
private static MediaProgram GetProgramDetails(IProgram program)
{
var programDetails = EntityFactory.BuildProgramFromIProgram(program);
return(programDetails);
}
public bool GetCurrentProgram(IChannel channel, out IProgram program)
{
program = null;
Channel indexChannel = channel as Channel;
if (indexChannel == null)
return false;
if (!CheckConnection(indexChannel.ServerIndex))
return false;
try
{
WebProgramDetailed tvProgram = TvServer(indexChannel.ServerIndex).GetCurrentProgramOnChannel(channel.ChannelId);
if (tvProgram != null)
{
program = new Program(tvProgram, indexChannel.ServerIndex);
return true;
}
}
catch (Exception ex)
{
ServiceRegistration.Get<ILogger>().Error(ex.Message);
}
return false;
}
/// <summary>
/// Initialize the cache.
/// </summary>
internal void Initialize()
{
if (GraphicsConfig.EnableShaderCache && GraphicsConfig.TitleId != null)
{
_cacheManager = new CacheManager(CacheGraphicsApi.OpenGL, CacheHashType.XxHash128, "glsl", GraphicsConfig.TitleId, ShaderCodeGenVersion);
bool isReadOnly = _cacheManager.IsReadOnly;
HashSet <Hash128> invalidEntries = null;
if (isReadOnly)
{
Logger.Warning?.Print(LogClass.Gpu, "Loading shader cache in read-only mode (cache in use by another program!)");
}
else
{
invalidEntries = new HashSet <Hash128>();
}
ReadOnlySpan <Hash128> guestProgramList = _cacheManager.GetGuestProgramList();
for (int programIndex = 0; programIndex < guestProgramList.Length; programIndex++)
{
Hash128 key = guestProgramList[programIndex];
Logger.Info?.Print(LogClass.Gpu, $"Compiling shader {key} ({programIndex + 1} / {guestProgramList.Length})");
byte[] hostProgramBinary = _cacheManager.GetHostProgramByHash(ref key);
bool hasHostCache = hostProgramBinary != null;
IProgram hostProgram = null;
// If the program sources aren't in the cache, compile from saved guest program.
byte[] guestProgram = _cacheManager.GetGuestProgramByHash(ref key);
if (guestProgram == null)
{
Logger.Error?.Print(LogClass.Gpu, $"Ignoring orphan shader hash {key} in cache (is the cache incomplete?)");
// Should not happen, but if someone messed with the cache it's better to catch it.
invalidEntries?.Add(key);
continue;
}
ReadOnlySpan <byte> guestProgramReadOnlySpan = guestProgram;
ReadOnlySpan <GuestShaderCacheEntry> cachedShaderEntries = GuestShaderCacheEntry.Parse(ref guestProgramReadOnlySpan, out GuestShaderCacheHeader fileHeader);
if (cachedShaderEntries[0].Header.Stage == ShaderStage.Compute)
{
Debug.Assert(cachedShaderEntries.Length == 1);
GuestShaderCacheEntry entry = cachedShaderEntries[0];
HostShaderCacheEntry[] hostShaderEntries = null;
// Try loading host shader binary.
if (hasHostCache)
{
hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan);
hostProgramBinary = hostProgramBinarySpan.ToArray();
hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary);
}
bool isHostProgramValid = hostProgram != null;
ShaderProgram program;
ShaderProgramInfo shaderProgramInfo;
// Reconstruct code holder.
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "", entry.Header.Size, entry.Header.SizeA);
shaderProgramInfo = hostShaderEntries[0].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
program = Translator.CreateContext(0, gpuAccessor, DefaultFlags | TranslationFlags.Compute).Translate(out shaderProgramInfo);
}
ShaderCodeHolder shader = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
// If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again.
if (hostProgram == null)
{
Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest...");
// Compile shader and create program as the shader program binary got invalidated.
shader.HostShader = _context.Renderer.CompileShader(ShaderStage.Compute, shader.Program.Code);
hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader.HostShader }, null);
// As the host program was invalidated, save the new entry in the cache.
hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), new ShaderCodeHolder[] { shader });
if (!isReadOnly)
{
if (hasHostCache)
{
_cacheManager.ReplaceHostProgram(ref key, hostProgramBinary);
}
else
{
Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)");
_cacheManager.AddHostProgram(ref key, hostProgramBinary);
}
}
}
_cpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shader));
}
else
{
Debug.Assert(cachedShaderEntries.Length == Constants.ShaderStages);
ShaderCodeHolder[] shaders = new ShaderCodeHolder[cachedShaderEntries.Length];
List <ShaderProgram> shaderPrograms = new List <ShaderProgram>();
TransformFeedbackDescriptor[] tfd = CacheHelper.ReadTransformationFeedbackInformations(ref guestProgramReadOnlySpan, fileHeader);
TranslationFlags flags = DefaultFlags;
if (tfd != null)
{
flags = TranslationFlags.Feedback;
}
TranslationCounts counts = new TranslationCounts();
HostShaderCacheEntry[] hostShaderEntries = null;
// Try loading host shader binary.
if (hasHostCache)
{
hostShaderEntries = HostShaderCacheEntry.Parse(hostProgramBinary, out ReadOnlySpan <byte> hostProgramBinarySpan);
hostProgramBinary = hostProgramBinarySpan.ToArray();
hostProgram = _context.Renderer.LoadProgramBinary(hostProgramBinary);
}
bool isHostProgramValid = hostProgram != null;
// Reconstruct code holder.
for (int i = 0; i < cachedShaderEntries.Length; i++)
{
GuestShaderCacheEntry entry = cachedShaderEntries[i];
if (entry == null)
{
continue;
}
ShaderProgram program;
if (entry.Header.SizeA != 0)
{
ShaderProgramInfo shaderProgramInfo;
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "", entry.Header.Size, entry.Header.SizeA);
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
program = Translator.CreateContext((ulong)entry.Header.Size, 0, gpuAccessor, flags, counts).Translate(out shaderProgramInfo);
}
// NOTE: Vertex B comes first in the shader cache.
byte[] code = entry.Code.AsSpan().Slice(0, entry.Header.Size).ToArray();
byte[] code2 = entry.Code.AsSpan().Slice(entry.Header.Size, entry.Header.SizeA).ToArray();
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, code, code2);
}
else
{
ShaderProgramInfo shaderProgramInfo;
if (isHostProgramValid)
{
program = new ShaderProgram(entry.Header.Stage, "", entry.Header.Size, entry.Header.SizeA);
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
}
else
{
IGpuAccessor gpuAccessor = new CachedGpuAccessor(_context, entry.Code, entry.Header.GpuAccessorHeader, entry.TextureDescriptors);
program = Translator.CreateContext(0, gpuAccessor, flags, counts).Translate(out shaderProgramInfo);
}
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, entry.Code);
}
shaderPrograms.Add(program);
}
// If the host program was rejected by the gpu driver or isn't in cache, try to build from program sources again.
if (!isHostProgramValid)
{
Logger.Info?.Print(LogClass.Gpu, $"Host shader {key} got invalidated, rebuilding from guest...");
List <IShader> hostShaders = new List <IShader>();
// Compile shaders and create program as the shader program binary got invalidated.
for (int stage = 0; stage < Constants.ShaderStages; stage++)
{
ShaderProgram program = shaders[stage]?.Program;
if (program == null)
{
continue;
}
IShader hostShader = _context.Renderer.CompileShader(program.Stage, program.Code);
shaders[stage].HostShader = hostShader;
hostShaders.Add(hostShader);
}
hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray(), tfd);
// As the host program was invalidated, save the new entry in the cache.
hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), shaders);
if (!isReadOnly)
{
if (hasHostCache)
{
_cacheManager.ReplaceHostProgram(ref key, hostProgramBinary);
}
else
{
Logger.Warning?.Print(LogClass.Gpu, $"Add missing host shader {key} in cache (is the cache incomplete?)");
_cacheManager.AddHostProgram(ref key, hostProgramBinary);
}
}
}
_gpProgramsDiskCache.Add(key, new ShaderBundle(hostProgram, shaders));
}
}
if (!isReadOnly)
{
// Remove entries that are broken in the cache
_cacheManager.RemoveManifestEntries(invalidEntries);
_cacheManager.FlushToArchive();
_cacheManager.Synchronize();
}
Logger.Info?.Print(LogClass.Gpu, "Shader cache loaded.");
}
}
public bool GetRecordingStatus(IProgram program, out RecordingStatus recordingStatus)
{
recordingStatus = RecordingStatus.None;
Program indexProgram = program as Program;
if (indexProgram == null)
return false;
if (!CheckConnection(indexProgram.ServerIndex))
return false;
try
{
WebProgramDetailed programDetailed = TvServer(indexProgram.ServerIndex).GetProgramDetailedById(program.ProgramId);
recordingStatus = Program.GetRecordingStatus(programDetailed);
}
catch
{
return false;
}
return true;
}
private static void CreateProgramListItem(IProgram program, ListItem itemToUpdate, IProgram previousProgram = null)
{
ProgramListItem item = itemToUpdate as ProgramListItem;
if (item == null)
{
return;
}
item.Program.SetProgram(program ?? GetNoProgram(previousProgram));
item.AdditionalProperties["PROGRAM"] = program;
item.Update();
}
/// <summary>
/// Tries to update a program item, i.e. if recording status was changed.
/// </summary>
/// <param name="program">Program</param>
private void UpdateProgramStatus(IProgram program)
{
if (program == null)
return;
FrameworkElement control = Children.FirstOrDefault(el =>
{
ProgramProperties programProperties = ((ProgramListItem)el.Context).Program;
return programProperties != null && programProperties.ProgramId == program.ProgramId;
});
if (control == null)
return;
// Update properties
IProgramRecordingStatus recordingStatus = program as IProgramRecordingStatus;
if (recordingStatus != null)
((ProgramListItem)control.Context).Program.IsScheduled = recordingStatus.RecordingStatus != RecordingStatus.None;
}
/// <summary>
/// Gets a compute shader from the cache.
/// </summary>
/// <remarks>
/// This automatically translates, compiles and adds the code to the cache if not present.
/// </remarks>
/// <param name="state">Current GPU state</param>
/// <param name="gpuVa">GPU virtual address of the binary shader code</param>
/// <param name="localSizeX">Local group size X of the computer shader</param>
/// <param name="localSizeY">Local group size Y of the computer shader</param>
/// <param name="localSizeZ">Local group size Z of the computer shader</param>
/// <param name="localMemorySize">Local memory size of the compute shader</param>
/// <param name="sharedMemorySize">Shared memory size of the compute shader</param>
/// <returns>Compiled compute shader code</returns>
public ShaderBundle GetComputeShader(
GpuState state,
ulong gpuVa,
int localSizeX,
int localSizeY,
int localSizeZ,
int localMemorySize,
int sharedMemorySize)
{
bool isCached = _cpPrograms.TryGetValue(gpuVa, out List <ShaderBundle> list);
if (isCached)
{
foreach (ShaderBundle cachedCpShader in list)
{
if (IsShaderEqual(cachedCpShader, gpuVa))
{
return(cachedCpShader);
}
}
}
TranslatorContext[] shaderContexts = new TranslatorContext[1];
shaderContexts[0] = DecodeComputeShader(
state,
gpuVa,
localSizeX,
localSizeY,
localSizeZ,
localMemorySize,
sharedMemorySize);
bool isShaderCacheEnabled = _cacheManager != null;
bool isShaderCacheReadOnly = false;
Hash128 programCodeHash = default;
GuestShaderCacheEntry[] shaderCacheEntries = null;
// Current shader cache doesn't support bindless textures
if (shaderContexts[0].UsedFeatures.HasFlag(FeatureFlags.Bindless))
{
isShaderCacheEnabled = false;
}
if (isShaderCacheEnabled)
{
isShaderCacheReadOnly = _cacheManager.IsReadOnly;
// Compute hash and prepare data for shader disk cache comparison.
shaderCacheEntries = CacheHelper.CreateShaderCacheEntries(_context.MemoryManager, shaderContexts);
programCodeHash = CacheHelper.ComputeGuestHashFromCache(shaderCacheEntries);
}
ShaderBundle cpShader;
// Search for the program hash in loaded shaders.
if (!isShaderCacheEnabled || !_cpProgramsDiskCache.TryGetValue(programCodeHash, out cpShader))
{
if (isShaderCacheEnabled)
{
Logger.Debug?.Print(LogClass.Gpu, $"Shader {programCodeHash} not in cache, compiling!");
}
// The shader isn't currently cached, translate it and compile it.
ShaderCodeHolder shader = TranslateShader(shaderContexts[0]);
shader.HostShader = _context.Renderer.CompileShader(ShaderStage.Compute, shader.Program.Code);
IProgram hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader.HostShader }, null);
hostProgram.CheckProgramLink(true);
byte[] hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), new ShaderCodeHolder[] { shader });
cpShader = new ShaderBundle(hostProgram, shader);
if (isShaderCacheEnabled)
{
_cpProgramsDiskCache.Add(programCodeHash, cpShader);
if (!isShaderCacheReadOnly)
{
_cacheManager.SaveProgram(ref programCodeHash, CacheHelper.CreateGuestProgramDump(shaderCacheEntries), hostProgramBinary);
}
}
}
if (!isCached)
{
list = new List <ShaderBundle>();
_cpPrograms.Add(gpuVa, list);
}
list.Add(cpShader);
return(cpShader);
}
public bool IsAvailable (IProgram program)
{
return true;
}
/// <summary>
/// Gets a graphics shader program from the shader cache.
/// This includes all the specified shader stages.
/// </summary>
/// <remarks>
/// This automatically translates, compiles and adds the code to the cache if not present.
/// </remarks>
/// <param name="state">Current GPU state</param>
/// <param name="addresses">Addresses of the shaders for each stage</param>
/// <returns>Compiled graphics shader code</returns>
public ShaderBundle GetGraphicsShader(GpuState state, ShaderAddresses addresses)
{
bool isCached = _gpPrograms.TryGetValue(addresses, out List <ShaderBundle> list);
if (isCached)
{
foreach (ShaderBundle cachedGpShaders in list)
{
if (IsShaderEqual(cachedGpShaders, addresses))
{
return(cachedGpShaders);
}
}
}
TranslatorContext[] shaderContexts = new TranslatorContext[Constants.ShaderStages + 1];
TransformFeedbackDescriptor[] tfd = GetTransformFeedbackDescriptors(state);
TranslationFlags flags = DefaultFlags;
if (tfd != null)
{
flags |= TranslationFlags.Feedback;
}
TranslationCounts counts = new TranslationCounts();
if (addresses.VertexA != 0)
{
shaderContexts[0] = DecodeGraphicsShader(state, counts, flags | TranslationFlags.VertexA, ShaderStage.Vertex, addresses.VertexA);
}
shaderContexts[1] = DecodeGraphicsShader(state, counts, flags, ShaderStage.Vertex, addresses.Vertex);
shaderContexts[2] = DecodeGraphicsShader(state, counts, flags, ShaderStage.TessellationControl, addresses.TessControl);
shaderContexts[3] = DecodeGraphicsShader(state, counts, flags, ShaderStage.TessellationEvaluation, addresses.TessEvaluation);
shaderContexts[4] = DecodeGraphicsShader(state, counts, flags, ShaderStage.Geometry, addresses.Geometry);
shaderContexts[5] = DecodeGraphicsShader(state, counts, flags, ShaderStage.Fragment, addresses.Fragment);
bool isShaderCacheEnabled = _cacheManager != null;
bool isShaderCacheReadOnly = false;
Hash128 programCodeHash = default;
GuestShaderCacheEntry[] shaderCacheEntries = null;
// Current shader cache doesn't support bindless textures
for (int i = 0; i < shaderContexts.Length; i++)
{
if (shaderContexts[i] != null && shaderContexts[i].UsedFeatures.HasFlag(FeatureFlags.Bindless))
{
isShaderCacheEnabled = false;
break;
}
}
if (isShaderCacheEnabled)
{
isShaderCacheReadOnly = _cacheManager.IsReadOnly;
// Compute hash and prepare data for shader disk cache comparison.
shaderCacheEntries = CacheHelper.CreateShaderCacheEntries(_context.MemoryManager, shaderContexts);
programCodeHash = CacheHelper.ComputeGuestHashFromCache(shaderCacheEntries, tfd);
}
ShaderBundle gpShaders;
// Search for the program hash in loaded shaders.
if (!isShaderCacheEnabled || !_gpProgramsDiskCache.TryGetValue(programCodeHash, out gpShaders))
{
if (isShaderCacheEnabled)
{
Logger.Debug?.Print(LogClass.Gpu, $"Shader {programCodeHash} not in cache, compiling!");
}
// The shader isn't currently cached, translate it and compile it.
ShaderCodeHolder[] shaders = new ShaderCodeHolder[Constants.ShaderStages];
shaders[0] = TranslateShader(shaderContexts[1], shaderContexts[0]);
shaders[1] = TranslateShader(shaderContexts[2]);
shaders[2] = TranslateShader(shaderContexts[3]);
shaders[3] = TranslateShader(shaderContexts[4]);
shaders[4] = TranslateShader(shaderContexts[5]);
List <IShader> hostShaders = new List <IShader>();
for (int stage = 0; stage < Constants.ShaderStages; stage++)
{
ShaderProgram program = shaders[stage]?.Program;
if (program == null)
{
continue;
}
IShader hostShader = _context.Renderer.CompileShader(program.Stage, program.Code);
shaders[stage].HostShader = hostShader;
hostShaders.Add(hostShader);
}
IProgram hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray(), tfd);
hostProgram.CheckProgramLink(true);
byte[] hostProgramBinary = HostShaderCacheEntry.Create(hostProgram.GetBinary(), shaders);
gpShaders = new ShaderBundle(hostProgram, shaders);
if (isShaderCacheEnabled)
{
_gpProgramsDiskCache.Add(programCodeHash, gpShaders);
if (!isShaderCacheReadOnly)
{
_cacheManager.SaveProgram(ref programCodeHash, CacheHelper.CreateGuestProgramDump(shaderCacheEntries, tfd), hostProgramBinary);
}
}
}
if (!isCached)
{
list = new List <ShaderBundle>();
_gpPrograms.Add(addresses, list);
}
list.Add(gpShaders);
return(gpShaders);
}
