diff --git a/MediaBrowser.Api/Playback/BifService.cs b/MediaBrowser.Api/Playback/BifService.cs
new file mode 100644
index 0000000000..7a3a7d32dc
--- /dev/null
+++ b/MediaBrowser.Api/Playback/BifService.cs
@@ -0,0 +1,181 @@
+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
+            {
+                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));
+        }
+    }
+}