You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
jellyfin/MediaBrowser.Api/Playback/BifService.cs

187 lines
6.9 KiB

using MediaBrowser.Common.IO;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.MediaEncoding;
using ServiceStack;
using System;
using System.Collections.Concurrent;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Api.Playback
{
[Route("/Videos/{Id}/index.bif", "GET")]
public class GetBifFile
{
[ApiMember(Name = "MediaSourceId", Description = "The media version id, if playing an alternate version", IsRequired = true, DataType = "string", ParameterType = "path", Verb = "GET")]
public string MediaSourceId { get; set; }
[ApiMember(Name = "MaxWidth", Description = "Optional. The maximum horizontal resolution of the encoded video.", IsRequired = false, DataType = "int", ParameterType = "query", Verb = "GET")]
public int? MaxWidth { get; set; }
[ApiMember(Name = "Id", Description = "Item Id", IsRequired = true, DataType = "string", ParameterType = "path", Verb = "GET")]
public string Id { get; set; }
}
public class BifService : BaseApiService
{
private readonly IServerApplicationPaths _appPaths;
private readonly ILibraryManager _libraryManager;
private readonly IMediaEncoder _mediaEncoder;
private readonly IFileSystem _fileSystem;
public BifService(IServerApplicationPaths appPaths, ILibraryManager libraryManager, IMediaEncoder mediaEncoder, IFileSystem fileSystem)
{
_appPaths = appPaths;
_libraryManager = libraryManager;
_mediaEncoder = mediaEncoder;
_fileSystem = fileSystem;
}
public object Get(GetBifFile request)
{
return ToStaticFileResult(GetBifFile(request).Result);
}
private async Task<string> GetBifFile(GetBifFile request)
{
var widthVal = request.MaxWidth.HasValue ? request.MaxWidth.Value.ToString(CultureInfo.InvariantCulture) : string.Empty;
var item = _libraryManager.GetItemById(request.Id);
var mediaSources = ((IHasMediaSources)item).GetMediaSources(false).ToList();
var mediaSource = mediaSources.FirstOrDefault(i => string.Equals(i.Id, request.MediaSourceId)) ?? mediaSources.First();
var path = Path.Combine(_appPaths.ImageCachePath, "bif", request.Id, request.MediaSourceId, widthVal, "index.bif");
if (File.Exists(path))
{
return path;
}
var protocol = mediaSource.Protocol;
var inputPath = MediaEncoderHelpers.GetInputArgument(mediaSource.Path, protocol, null, mediaSource.PlayableStreamFileNames);
var semaphore = GetLock(path);
await semaphore.WaitAsync().ConfigureAwait(false);
try
{
if (File.Exists(path))
{
return path;
}
await _mediaEncoder.ExtractVideoImagesOnInterval(inputPath, protocol, mediaSource.Video3DFormat,
TimeSpan.FromSeconds(10), Path.GetDirectoryName(path), "img_", request.MaxWidth, CancellationToken.None)
.ConfigureAwait(false);
var images = new DirectoryInfo(Path.GetDirectoryName(path))
.EnumerateFiles()
.Where(img => string.Equals(img.Extension, ".jpg", StringComparison.Ordinal))
.OrderBy(i => i.FullName)
.ToList();
using (var fs = _fileSystem.GetFileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read, true))
{
var magicNumber = new byte[] { 0x89, 0x42, 0x49, 0x46, 0x0d, 0x0a, 0x1a, 0x0a };
await fs.WriteAsync(magicNumber, 0, magicNumber.Length);
// version
var bytes = GetBytes(0);
await fs.WriteAsync(bytes, 0, bytes.Length);
// image count
bytes = GetBytes(images.Count);
await fs.WriteAsync(bytes, 0, bytes.Length);
// interval in ms
bytes = GetBytes(10000);
await fs.WriteAsync(bytes, 0, bytes.Length);
// reserved
for (var i = 20; i <= 63; i++)
{
bytes = new byte[] { 0x00 };
await fs.WriteAsync(bytes, 0, bytes.Length);
}
// write the bif index
var index = 0;
long imageOffset = 64 + (8 * images.Count) + 8;
foreach (var img in images)
{
bytes = GetBytes(index);
await fs.WriteAsync(bytes, 0, bytes.Length);
bytes = GetBytes(imageOffset);
await fs.WriteAsync(bytes, 0, bytes.Length);
imageOffset += img.Length;
index++;
}
bytes = new byte[] { 0xff, 0xff, 0xff, 0xff };
await fs.WriteAsync(bytes, 0, bytes.Length);
bytes = GetBytes(imageOffset);
await fs.WriteAsync(bytes, 0, bytes.Length);
// write the images
foreach (var img in images)
{
using (var imgStream = _fileSystem.GetFileStream(img.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, true))
{
await imgStream.CopyToAsync(fs).ConfigureAwait(false);
}
}
}
return path;
}
finally
{
semaphore.Release();
}
}
private byte[] GetBytes(int value)
{
byte[] bytes = BitConverter.GetBytes(value);
if (BitConverter.IsLittleEndian)
Array.Reverse(bytes);
return bytes;
}
private byte[] GetBytes(long value)
{
var intVal = Convert.ToInt32(value);
return GetBytes(intVal);
//byte[] bytes = BitConverter.GetBytes(value);
//if (BitConverter.IsLittleEndian)
// Array.Reverse(bytes);
//return bytes;
}
private static readonly ConcurrentDictionary<string, SemaphoreSlim> SemaphoreLocks = new ConcurrentDictionary<string, SemaphoreSlim>();
/// <summary>
/// Gets the lock.
/// </summary>
/// <param name="filename">The filename.</param>
/// <returns>System.Object.</returns>
private static SemaphoreSlim GetLock(string filename)
{
return SemaphoreLocks.GetOrAdd(filename, key => new SemaphoreSlim(1, 1));
}
}
}