/// <summary>
/// Validate Media Format
/// </summary>
/// <param name="mediaDescriptor">The Media session preamble</param>
/// <param name="errorMessage">Error message</param>
/// <returns></returns>
public bool IsMediaFormatSupported(MediaDescriptor mediaDescriptor, out string errorMessage)
{
errorMessage = null;
logger.LogInformation($"IsMediaFormatSupported {mediaDescriptor.MediaSampleFormatCase}:{mediaDescriptor.VideoFrameSampleFormat.Encoding}:{mediaDescriptor.VideoFrameSampleFormat.PixelFormat}.");
switch (mediaDescriptor.MediaSampleFormatCase)
{
case MediaDescriptor.MediaSampleFormatOneofCase.VideoFrameSampleFormat:
var videoSampleFormat = mediaDescriptor.VideoFrameSampleFormat;
if (videoSampleFormat.Encoding != VideoFrameSampleFormat.Types.Encoding.Jpg)
{
errorMessage = $"{videoSampleFormat.Encoding} encoding is not supported. Supported: Jpg";
return(false);
}
if (videoSampleFormat.PixelFormat != VideoFrameSampleFormat.Types.PixelFormat.None)
{
errorMessage = $"{videoSampleFormat.PixelFormat} pixel format is not supported. Supported: None";
return(false);
}
return(true);
default:
errorMessage = $"Unsupported sample format: {mediaDescriptor.MediaSampleFormatCase}";
return(false);
}
}
/// Process the Media Stream session preamble.
/// </summary>
/// <param name="mediaStreamDescriptor">Media session preamble.</param>
/// <returns>Preamble response.</returns>
public MediaStreamDescriptor ProcessMediaStreamDescriptor(MediaStreamDescriptor mediaStreamDescriptor)
{
// Setup data transfer
switch (mediaStreamDescriptor.DataTransferPropertiesCase)
{
case MediaStreamDescriptor.DataTransferPropertiesOneofCase.SharedMemoryBufferTransferProperties:
var memoryMappedFileProperties = mediaStreamDescriptor.SharedMemoryBufferTransferProperties;
// Create a view on the memory mapped file.
_logger.LogInformation($"Using shared memory transfer. Handle: {memoryMappedFileProperties.HandleName}, Size:{memoryMappedFileProperties.LengthBytes}");
try
{
_memoryManager = new MemoryMappedFileMemoryManager <byte>(
memoryMappedFileProperties.HandleName,
(int)memoryMappedFileProperties.LengthBytes,
desiredAccess: MemoryMappedFileAccess.Read);
_memory = _memoryManager.Memory;
}
catch (Exception ex)
{
_logger.LogError($"Error creating memory manager: {ex.Message}");
throw new RpcException(
new Status(
StatusCode.InvalidArgument,
$"Error creating memory manager: {ex.Message}"));
}
break;
case MediaStreamDescriptor.DataTransferPropertiesOneofCase.None:
// Nothing to be done.
_logger.LogInformation("Using embedded frame transfer.");
break;
default:
_logger.LogInformation($"Unsupported data transfer method: {mediaStreamDescriptor.DataTransferPropertiesCase}");
throw new RpcException(new Status(StatusCode.OutOfRange, $"Unsupported data transfer method: {mediaStreamDescriptor.DataTransferPropertiesCase}"));
}
// Validate encoding
if (!_imageProcessor.IsMediaFormatSupported(mediaStreamDescriptor.MediaDescriptor, out var errorMessage))
{
_logger.LogInformation($"validate enconding: {errorMessage}");
throw new RpcException(new Status(StatusCode.OutOfRange, errorMessage));
}
// Cache the client media descriptor for this stream
_clientMediaDescriptor = mediaStreamDescriptor.MediaDescriptor;
// Return a empty server stream descriptor as no samples are returned (only inferences)
return(new MediaStreamDescriptor {
MediaDescriptor = new MediaDescriptor {
Timescale = _clientMediaDescriptor.Timescale
}
});
}
private async Task SeedMediaAsync()
{
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(_cmsKitTestData.Media_1_Content)))
{
var media = new MediaDescriptor(_cmsKitTestData.Media_1_Id, _cmsKitTestData.Media_1_Name, _cmsKitTestData.Media_1_ContentType, stream.Length);
await _mediaDescriptorRepository.InsertAsync(media);
await _mediaBlobContainer.SaveAsync(media.Id.ToString(), stream);
}
}
public virtual async Task <MediaDescriptorDto> CreateAsync(CreateMediaInputStream inputStream)
{
var newId = GuidGenerator.Create();
var stream = inputStream.GetStream();
var newEntity = new MediaDescriptor(newId, inputStream.Name, inputStream.ContentType, stream.Length, CurrentTenant.Id);
await MediaContainer.SaveAsync(newId.ToString(), stream);
await MediaDescriptorRepository.InsertAsync(newEntity);
return(ObjectMapper.Map <MediaDescriptor, MediaDescriptorDto>(newEntity));
}
private void clickFile(object sender, EventArgs args)
{
if (service != null)
{
DialogResult dr = fileDialog.ShowDialog();
if (dr == DialogResult.OK)
{
result = fileDialog.FileName;
MediaDescriptor aDesc = ProjectManager.Instance.ActiveProject.addMedia(result);
result = aDesc.Name;
}
service.CloseDropDown();
}
}
/// <summary>
/// Validate Media Format
/// </summary>
/// <param name="mediaDescriptor">The Media session preamble</param>
/// <param name="errorMessage">Error message</param>
/// <returns></returns>
public bool IsMediaFormatSupported(MediaDescriptor mediaDescriptor, out string errorMessage)
{
errorMessage = null;
switch (mediaDescriptor.MediaSampleFormatCase)
{
case MediaDescriptor.MediaSampleFormatOneofCase.VideoFrameSampleFormat:
var videoSampleFormat = mediaDescriptor.VideoFrameSampleFormat;
if (videoSampleFormat.Encoding != VideoFrameSampleFormat.Types.Encoding.Raw)
{
errorMessage = $"{videoSampleFormat.Encoding} encoding is not supported. Supported: Raw";
return(false);
}
return(true);
default:
errorMessage = $"Unsupported sample format: {mediaDescriptor.MediaSampleFormatCase}";
return(false);
}
}
public MediaItem(ITrackCollection media, MediaDescriptor descriptor)
{
Descriptor = descriptor;
Media = media;
}
public UrlParseSuccess(MediaDescriptor descriptor)
{
MediaDescriptor = descriptor;
}
public static IUrlParseResult Success(MediaDescriptor descriptor) => new UrlParseSuccess(descriptor);
public MediaResolver(MediaDescriptor descriptor)
{
this.descriptor = descriptor;
}
