Adds basic archive support.

 Reading archives uses 7zip code.

 The project can be found here: https://github.com/aidan-g/BASS_ZIPSTREAM

FoxTunes.Core/Interfaces/MetaData/IFileAbstraction.cs

@@ -0,0 +1,16 @@
+using System;
+using System.IO;
+
+namespace FoxTunes.Interfaces
+{
+    public interface IFileAbstraction : IDisposable
+    {
+        string FileName { get; }
+
+        Stream ReadStream { get; }
+
+        Stream WriteStream { get; }
+
+        void CloseStream(Stream stream);
+    }
+}

FoxTunes.Core/Interfaces/MetaData/IMetaDataSource.cs

@@ -10,6 +10,8 @@ public interface IMetaDataSource : IBaseComponent
 
         Task<IEnumerable<MetaDataItem>> GetMetaData(string fileName);
 
+        Task<IEnumerable<MetaDataItem>> GetMetaData(IFileAbstraction fileAbstraction);
+
         Task SetMetaData(string fileName, IEnumerable<MetaDataItem> metaDataItems, Func<MetaDataItem, bool> predicate);
     }
 

FoxTunes.MetaData.FileName/FileNameMetaDataSource.cs

@@ -102,6 +102,11 @@ public async Task<IEnumerable<MetaDataItem>> GetMetaData(string fileName)
             return result;
         }
 
+        public Task<IEnumerable<MetaDataItem>> GetMetaData(IFileAbstraction fileAbstraction)
+        {
+            throw new NotImplementedException();
+        }
+
         protected virtual MetaDataItem GetMetaData(string name, string value)
         {
             return new MetaDataItem(name, MetaDataItemType.Tag)

FoxTunes.MetaData.TagLib/Mpeg4/File.cs

@@ -49,6 +49,11 @@ public Task<IEnumerable<MetaDataItem>> GetMetaData(string fileName)
 #endif
         }
 
+        public Task<IEnumerable<MetaDataItem>> GetMetaData(global::FoxTunes.Interfaces.IFileAbstraction fileAbstraction)
+        {
+            throw new NotImplementedException();
+        }
+
         public Task SetMetaData(string fileName, IEnumerable<MetaDataItem> metaDataItems, Func<MetaDataItem, bool> predicate)
         {
             var box = this.GetXtraBox();

FoxTunes.MetaData.TagLib/TagLibFileAbstraction.cs

@@ -0,0 +1,53 @@
+using FoxTunes.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace FoxTunes
+{
+    public class TagLibFileAbstraction : global::TagLib.File.IFileAbstraction
+    {
+        public TagLibFileAbstraction(IFileAbstraction fileAbstraction)
+        {
+            this.FileAbstraction = fileAbstraction;
+        }
+
+        public IFileAbstraction FileAbstraction { get; private set; }
+
+        public string Name
+        {
+            get
+            {
+                return this.FileAbstraction.FileName;
+            }
+        }
+
+        public Stream ReadStream
+        {
+            get
+            {
+                return this.FileAbstraction.ReadStream;
+            }
+        }
+
+        public Stream WriteStream
+        {
+            get
+            {
+                return this.FileAbstraction.WriteStream;
+            }
+        }
+
+        public void CloseStream(Stream stream)
+        {
+            this.FileAbstraction.CloseStream(stream);
+        }
+
+        public static TagLibFileAbstraction Create(IFileAbstraction fileAbstraction)
+        {
+            return new TagLibFileAbstraction(fileAbstraction);
+        }
+    }
+}

FoxTunes.MetaData.TagLib/TagLibFileFactory.cs

@@ -36,6 +36,11 @@ public File Create(string fileName)
             return file;
         }
 
+        public File Create(IFileAbstraction fileAbstraction)
+        {
+            return File.Create(TagLibFileAbstraction.Create(fileAbstraction));
+        }
+
         public IEnumerable<ConfigurationSection> GetConfigurationSections()
         {
             return TagLibFileFactoryConfiguration.GetConfigurationSections();

FoxTunes.MetaData.TagLib/TagLibMetaDataSource.cs

@@ -126,7 +126,17 @@ public override void InitializeComponent(ICore core)
             base.InitializeComponent(core);
         }
 
-        public async Task<IEnumerable<MetaDataItem>> GetMetaData(string fileName)
+        public Task<IEnumerable<MetaDataItem>> GetMetaData(string fileName)
+        {
+            return this.GetMetaData(fileName, () => this.FileFactory.Create(fileName));
+        }
+
+        public Task<IEnumerable<MetaDataItem>> GetMetaData(IFileAbstraction fileAbstraction)
+        {
+            return this.GetMetaData(fileAbstraction.FileName, () => this.FileFactory.Create(fileAbstraction));
+        }
+
+        public async Task<IEnumerable<MetaDataItem>> GetMetaData(string fileName, Func<File> factory)
         {
             if (!this.IsSupported(fileName))
             {
@@ -139,7 +149,7 @@ public async Task<IEnumerable<MetaDataItem>> GetMetaData(string fileName)
             Logger.Write(this, LogLevel.Trace, "Reading meta data for file: {0}", fileName);
             try
             {
-                using (var file = this.FileFactory.Create(fileName))
+                using (var file = factory())
                 {
                     if (file.PossiblyCorrupt)
                     {

FoxTunes.Output.Bass.Archive/BassArchiveStreamProvider.cs

@@ -0,0 +1,68 @@
+using FoxTunes.Interfaces;
+using ManagedBass;
+using ManagedBass.ZipStream;
+using System.Collections.Generic;
+
+namespace FoxTunes
+{
+    public class BassArchiveStreamProvider : BassStreamProvider
+    {
+        public BassArchiveStreamProviderBehaviour Behaviour { get; private set; }
+
+        public override void InitializeComponent(ICore core)
+        {
+            this.Behaviour = ComponentRegistry.Instance.GetComponent<BassArchiveStreamProviderBehaviour>();
+            base.InitializeComponent(core);
+        }
+
+        public override bool CanCreateStream(PlaylistItem playlistItem)
+        {
+            //The behaviour is not loaded for utilities so we can't check whether it's enabled.
+            //if (this.Behaviour == null || !this.Behaviour.Enabled)
+            //{
+            //    return false;
+            //}
+            var fileName = default(string);
+            var entryName = default(string);
+            return ArchiveUtils.ParseUrl(playlistItem.FileName, out fileName, out entryName);
+        }
+
+        public override IBassStream CreateBasicStream(PlaylistItem playlistItem, IEnumerable<IBassStreamAdvice> advice, BassFlags flags)
+        {
+            var fileName = default(string);
+            var entryName = default(string);
+            if (!ArchiveUtils.ParseUrl(playlistItem.FileName, out fileName, out entryName))
+            {
+                //This shouldn't happen as CanCreateStream would have returned false.
+                return BassStream.Empty;
+            }
+            var index = default(int);
+            if (!ArchiveUtils.GetEntryIndex(fileName, entryName, out index))
+            {
+                //The associated entry was not found.
+                return BassStream.Empty;
+            }
+            var channelHandle = BassZipStream.CreateStream(fileName, index, Flags: flags);
+            return this.CreateBasicStream(channelHandle, advice, flags);
+        }
+
+        public override IBassStream CreateInteractiveStream(PlaylistItem playlistItem, IEnumerable<IBassStreamAdvice> advice, BassFlags flags)
+        {
+            var fileName = default(string);
+            var entryName = default(string);
+            if (!ArchiveUtils.ParseUrl(playlistItem.FileName, out fileName, out entryName))
+            {
+                //This shouldn't happen as CanCreateStream would have returned false.
+                return BassStream.Empty;
+            }
+            var index = default(int);
+            if (!ArchiveUtils.GetEntryIndex(fileName, entryName, out index))
+            {
+                //The associated entry was not found.
+                return BassStream.Empty;
+            }
+            var channelHandle = BassZipStream.CreateStream(fileName, index, Flags: flags);
+            return this.CreateInteractiveStream(channelHandle, advice, flags);
+        }
+    }
+}