nixo
/
amazfitbiptools
mirror of https://bitbucket.org/valeronm/amazfitbiptools
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Added support for non image resources

master
Valeriy Mironov 2019-05-04 11:44:19 +03:00
parent baa352661d
commit 4ad3537a26
19 changed files with 243 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Resources/Extractor.cs
View File

@ -18,12 +18,16 @@ namespace Resources
public void Extract(string outputDirectory)
{
for (var i = 0; i < _descriptor.Images.Count; i++)
for (var i = 0; i < _descriptor.Resources.Count; i++)
{
var resource = _descriptor.Resources[i];
var numericPart = i.ToString().PadLeft(ImageLoader.NumericPartLength, '0');
var fileName = Path.Combine(outputDirectory, numericPart + ".png");
var fileName = Path.Combine(outputDirectory, numericPart + resource.Extension);
Logger.Debug("Extracting {0}...", fileName);
_descriptor.Images[i].Save(fileName, ImageFormat.Png);
using (var fileStream = File.OpenWrite(fileName))
resource.ExportTo(fileStream);
}
}
}

2
Resources/FileReader.cs
View File

@ -40,7 +40,7 @@ namespace Resources
ResourcesCount = header.ResourcesCount,
Version = header.Version,
Unknown = (header as NewHeader)?.Unknown,
Images = new Reader(stream).Read(header.ResourcesCount)
Resources = new Reader(stream).Read(header.ResourcesCount)
};
}
}

4
Resources/FileWriter.cs
View File

@ -29,14 +29,14 @@ namespace Resources
WriteOldHeader(descriptor);
Logger.Trace("Writing images...");
new Writer(_stream).Write(descriptor.Images);
new Writer(_stream).Write(descriptor.Resources);
}
private void WriteOldHeader(FileDescriptor descriptor)
{
var header = new Header
{
ResourcesCount = (uint)descriptor.Images.Count,
ResourcesCount = (uint)descriptor.Resources.Count,
Version = descriptor.Version.Value
};
Logger.Trace("Writing resources header...");

6
Resources/Image/Reader.cs
View File

@ -1,5 +1,4 @@
using System;
using System.Drawing;
using System.Drawing;
using System.IO;
using BumpKit;
using NLog;
@ -29,7 +28,7 @@ namespace Resources.Image
{
var signature = _reader.ReadChars(4);
if (signature[0] != 'B' || signature[1] != 'M')
throw new ArgumentException("Image signature doesn't match.");
throw new InvalidResourceException("Image signature doesn't match.");
ReadHeader();
ReadPalette();
@ -94,6 +93,7 @@ namespace Resources.Image
}
}
}
return image;
}
}

61
Resources/ImageLoader.cs
View File

@ -1,9 +1,11 @@
using System.Drawing;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using NLog;
using Resources.Image;
using Resources.Models;
namespace Resources
{
@ -12,33 +14,58 @@ namespace Resources
public static readonly int NumericPartLength = 4;
private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
public static Bitmap LoadImageForNumber(string directory, long index)
public static IResource LoadResourceForNumber(string directory, long index)
{
var strIndex = index.ToString();
var numericParts = new[]
{
index.ToString().PadLeft(4, '0'),
index.ToString().PadLeft(3, '0'),
index.ToString().PadLeft(2, '0'),
index.ToString()
};
strIndex.PadLeft(4, '0'), strIndex.PadLeft(3, '0'), strIndex.PadLeft(2, '0'), strIndex
}.Distinct();
foreach (var numericPart in numericParts.Distinct())
foreach (var numericPart in numericParts)
{
var fullFileName = Path.Combine(directory, numericPart + ".png");
if (!File.Exists(fullFileName))
{
Logger.Trace("File {0} doesn't exists.", fullFileName);
continue;
}
var resource = TryLoadBitmap(directory, numericPart);
if (resource != null) return resource;
var image = (Bitmap) System.Drawing.Image.FromFile(fullFileName);
Logger.Trace("Image was loaded from file {0}", fullFileName);
return ApplyDithering(image);
resource = TryLoadBlob(directory, numericPart);
if (resource != null) return resource;
}
throw new FileNotFoundException($"File referenced by index {index} not found.");
}
private static IResource TryLoadBitmap(string directory, string numericPart)
{
var fullFileName = Path.Combine(directory, numericPart + Models.Image.ResourceExtension);
if (!File.Exists(fullFileName))
{
Logger.Trace("File {0} doesn't exists.", fullFileName);
return null;
}
var image = (Bitmap) System.Drawing.Image.FromFile(fullFileName);
Logger.Trace("Image was loaded from file {0}", fullFileName);
var ditheredBitmap = ApplyDithering(image);
return new Models.Image(ditheredBitmap);
}
private static IResource TryLoadBlob(string directory, string numericPart)
{
var fullFileName = Path.Combine(directory, numericPart + Blob.ResourceExtension);
if (!File.Exists(fullFileName))
{
Logger.Trace("File {0} doesn't exists.", fullFileName);
return null;
}
using (var fileStream = File.OpenRead(fullFileName))
{
var data = new byte[fileStream.Length];
fileStream.Read(data, 0, data.Length);
return new Blob(data);
}
}
private static Bitmap ApplyDithering(Bitmap image)
{
var clone = new Bitmap(image.Width, image.Height, PixelFormat.Format32bppArgb);

9
Resources/InvalidResourceException.cs Normal file
View File

@ -0,0 +1,9 @@
using System;
namespace Resources
{
public class InvalidResourceException : Exception
{
public InvalidResourceException(string message) : base(message) { }
}
}

27
Resources/Models/Blob.cs Normal file
View File

@ -0,0 +1,27 @@
using System.IO;
namespace Resources.Models
{
public class Blob : IResource
{
public static string ResourceExtension = ".dat";
private readonly byte[] _data;
public Blob(byte[] data)
{
_data = data;
}
public string Extension => ResourceExtension;
public void WriteTo(Stream stream)
{
stream.Write(_data, 0, _data.Length);
}
public void ExportTo(Stream stream)
{
stream.Write(_data, 0, _data.Length);
}
}
}

3
Resources/Models/FileDescriptor.cs
View File

@ -1,5 +1,6 @@
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.Serialization;
namespace Resources.Models
@ -12,6 +13,6 @@ namespace Resources.Models
public byte? Version { get; set; }
[IgnoreDataMember]
public List<Bitmap> Images { get; set; } = new List<Bitmap>();
public List<IResource> Resources { get; set; } = new List<IResource>();
}
}

11
Resources/Models/IResource.cs Normal file
View File

@ -0,0 +1,11 @@
using System.IO;
namespace Resources.Models
{
public interface IResource
{
string Extension { get; }
void WriteTo(Stream stream);
void ExportTo(Stream stream);
}
}

29
Resources/Models/Image.cs Normal file
View File

@ -0,0 +1,29 @@
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
namespace Resources.Models
{
public class Image: IResource
{
public Bitmap Bitmap { get; }
public Image(Bitmap bitmap)
{
Bitmap = bitmap;
}
public static string ResourceExtension = ".png";
public string Extension => ResourceExtension;
public void WriteTo(Stream stream)
{
new Resources.Image.Writer(stream).Write(Bitmap);
}
public void ExportTo(Stream stream)
{
Bitmap.Save(stream, ImageFormat.Png);
}
}
}

61
Resources/Reader.cs
View File

@ -1,8 +1,7 @@
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Collections.Generic;
using System.IO;
using NLog;
using Resources.Models;
namespace Resources
{
@ -20,32 +19,54 @@ namespace Resources
_binaryReader = new BinaryReader(_stream);
}
public List<Bitmap> Read(uint imagesTableLength)
public List<IResource> Read(uint resourcesCount)
{
var offsetsTableLength = (int) (imagesTableLength * OffsetTableItemLength);
var offsetsTableLength = (int) (resourcesCount * OffsetTableItemLength);
Logger.Trace("Reading resources offsets table with {0} elements ({1} bytes)",
imagesTableLength, offsetsTableLength
resourcesCount, offsetsTableLength
);
var imagesOffsets = _binaryReader.ReadBytes(offsetsTableLength);
var imagesOffset = _stream.Position;
Logger.Debug("Reading {0} images...", imagesTableLength);
var images = new List<Bitmap>((int) imagesTableLength);
for (var i = 0; i < imagesTableLength; i++)
var offsets = new int[resourcesCount];
for (var i = 0; i < resourcesCount; i++)
offsets[i] = _binaryReader.ReadInt32();
var resourcesOffset = (int) _stream.Position;
var fileSize = (int) _stream.Length;
Logger.Debug("Reading {0} resources...", resourcesCount);
var resources = new List<IResource>((int) resourcesCount);
for (var i = 0; i < resourcesCount; i++)
{
var imageOffset = BitConverter.ToUInt32(imagesOffsets, i * OffsetTableItemLength);
var realOffset = imageOffset + imagesOffset;
Logger.Trace("Image {0} offset is {1}...", i, imageOffset);
if (_stream.Position != realOffset)
var offset = offsets[i] + resourcesOffset;
var nextOffset = i + 1 < resourcesCount ? offsets[i + 1] + resourcesOffset : fileSize;
var length = nextOffset - offset;
Logger.Trace("Resource {0} offset: {1}, length: {2}...", i, offset, length);
if (_stream.Position != offset)
{
var bytesGap = realOffset - _stream.Position;
var bytesGap = offset - _stream.Position;
Logger.Warn("Found {0} bytes gap before resource number {1}", bytesGap, i);
_stream.Seek(realOffset, SeekOrigin.Begin);
_stream.Seek(offset, SeekOrigin.Begin);
}
Logger.Debug("Reading resource {0}...", i);
try
{
var bitmap = new Image.Reader(_stream).Read();
var image = new Models.Image(bitmap);
resources.Add(image);
}
catch (InvalidResourceException)
{
Logger.Warn("Resource is not an image");
_stream.Seek(offset, SeekOrigin.Begin);
var data = new byte[length];
_stream.Read(data, 0, length);
var blob = new Blob(data);
resources.Add(blob);
}
Logger.Debug("Reading image {0}...", i);
images.Add(new Image.Reader(_stream).Read());
}
return images;
return resources;
}
}
}

12
Resources/Resource.cs Normal file
View File

@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Resources
{
interface IResource
{
}
}

4
Resources/Resources.csproj
View File

@ -53,6 +53,10 @@
<ItemGroup>
<Compile Include="Extractor.cs" />
<Compile Include="ImageLoader.cs" />
<Compile Include="InvalidResourceException.cs" />
<Compile Include="Models\Blob.cs" />
<Compile Include="Models\Image.cs" />
<Compile Include="Models\IResource.cs" />
<Compile Include="Models\FileDescriptor.cs" />
<Compile Include="Models\Header.cs" />
<Compile Include="Utils\BitReader.cs" />

23
Resources/Writer.cs
View File

@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.Drawing;
using System.IO;
using NLog;
using Resources.Models;
namespace Resources
{
@ -18,30 +19,30 @@ namespace Resources
_stream = stream;
}
public void Write(List<Bitmap> images)
public void Write(List<IResource> resources)
{
var offsetsTable = new byte[images.Count * OffsetTableItemLength];
var encodedImages = new MemoryStream[images.Count];
var offsetsTable = new byte[resources.Count * OffsetTableItemLength];
var encodedResources = new MemoryStream[resources.Count];
var offset = (uint) 0;
for (var i = 0; i < images.Count; i++)
for (var i = 0; i < resources.Count; i++)
{
Logger.Trace("Image {0} offset is {1}...", i, offset);
Logger.Trace("Resource {0} offset is {1}...", i, offset);
var offsetBytes = BitConverter.GetBytes(offset);
offsetBytes.CopyTo(offsetsTable, i * OffsetTableItemLength);
var encodedImage = new MemoryStream();
Logger.Debug("Encoding image {0}...", i);
new Image.Writer(encodedImage).Write(images[i]);
Logger.Debug("Encoding resource {0}...", i);
resources[i].WriteTo(encodedImage);
offset += (uint) encodedImage.Length;
encodedImages[i] = encodedImage;
encodedResources[i] = encodedImage;
}
Logger.Trace("Writing images offsets table");
Logger.Trace("Writing resources offsets table");
_stream.Write(offsetsTable, 0, offsetsTable.Length);
Logger.Debug("Writing images");
foreach (var encodedImage in encodedImages)
Logger.Debug("Writing resources");
foreach (var encodedImage in encodedResources)
{
encodedImage.Seek(0, SeekOrigin.Begin);
encodedImage.CopyTo(_stream);

9
WatchFace.Parser/Reader.cs
View File

@ -1,8 +1,12 @@
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using NLog;
using Resources.Models;
using WatchFace.Parser.Models;
using Header = WatchFace.Parser.Models.Header;
using Image = Resources.Models.Image;
namespace WatchFace.Parser
{
@ -18,7 +22,8 @@ namespace WatchFace.Parser
}
public List<Parameter> Parameters { get; private set; }
public List<Bitmap> Images { get; private set; }
public List<IResource> Resources { get; private set; }
public Bitmap[] Images => Resources.OfType<Image>().Select(i => i.Bitmap).ToArray();
public void Read()
{
@ -46,7 +51,7 @@ namespace WatchFace.Parser
Logger.Trace("Watch face parameters locations were read:");
Parameters = ReadParameters(parametrsTableLength, parametersLocations);
Images = new Resources.Reader(_stream).Read((uint) imagesCount);
Resources = new Resources.Reader(_stream).Read((uint) imagesCount);
}
private List<Parameter> ReadParameters(long coordinatesTableSize, ICollection<Parameter> parametersDescriptors)

27
WatchFace.Parser/Utils/ImagesLoader.cs → WatchFace.Parser/Utils/ResourcesLoader.cs
View File

@ -1,31 +1,35 @@
using System;
using NLog;
using Resources;
using System;
using System.Collections.Generic;
using System.Drawing;
using NLog;
using Resources;
using System.Linq;
using Resources.Models;
using WatchFace.Parser.Attributes;
using Image = Resources.Models.Image;
namespace WatchFace.Parser.Utils
{
public class ImagesLoader
public class ResourcesLoader
{
private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
private readonly string _imagesDirectory;
private readonly Dictionary<long, long> _mapping;
public ImagesLoader(string imagesDirectory)
public ResourcesLoader(string imagesDirectory)
{
Images = new List<Bitmap>();
Resources = new List<IResource>();
_mapping = new Dictionary<long, long>();
_imagesDirectory = imagesDirectory;
}
public List<Bitmap> Images { get; }
public List<IResource> Resources { get; }
public Bitmap[] Images => Resources.OfType<Image>().Select(i => i.Bitmap).ToArray();
public void Process<T>(T serializable, string path = "")
{
if (!string.IsNullOrEmpty(path)) Logger.Trace("Loading images for {0} '{1}'", path, typeof(T).Name);
if (!string.IsNullOrEmpty(path)) Logger.Trace("Loading resources for {0} '{1}'", path, typeof(T).Name);
long? lastImageIndexValue = null;
@ -67,7 +71,7 @@ namespace WatchFace.Parser.Utils
{
if (lastImageIndexValue == null)
throw new ArgumentException(
$"Property {propertyInfo.Name} can't be processed becuase ImageIndex isn't present or it is zero"
$"Property {propertyInfo.Name} can't be processed because ImageIndex isn't present or it is zero"
);
var imagesCount = propertyType.IsGenericType
@ -102,9 +106,10 @@ namespace WatchFace.Parser.Utils
if (_mapping.ContainsKey(index))
return _mapping[index];
var newImageIndex = Images.Count;
var newImageIndex = Resources.Count;
Logger.Trace("Loading image {0}...", newImageIndex);
Images.Add(ImageLoader.LoadImageForNumber(_imagesDirectory, index));
var resource = ImageLoader.LoadResourceForNumber(_imagesDirectory, index);
Resources.Add(resource);
_mapping[index] = newImageIndex;
return newImageIndex;
}

2
WatchFace.Parser/WatchFace.Parser.csproj
View File

@ -160,7 +160,7 @@
<Compile Include="Attributes\ParameterImagesCountAttribute.cs" />
<Compile Include="Utils\DrawingOrderIterator.cs" />
<Compile Include="Utils\ElementsHelper.cs" />
<Compile Include="Utils\ImagesLoader.cs" />
<Compile Include="Utils\ResourcesLoader.cs" />
<Compile Include="Utils\ParametersConverter.cs" />
<Compile Include="Attributes\ParameterImageIndexAttribute.cs" />
<Compile Include="Attributes\ParameterIdAttribute.cs" />

6
WatchFace.Parser/Writer.cs
View File

@ -2,18 +2,20 @@
using System.Drawing;
using System.IO;
using NLog;
using Resources.Models;
using WatchFace.Parser.Models;
using Header = WatchFace.Parser.Models.Header;
namespace WatchFace.Parser
{
public class Writer
{
private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
private readonly List<Bitmap> _images;
private readonly List<IResource> _images;
private readonly Stream _stream;
public Writer(Stream stream, List<Bitmap> images)
public Writer(Stream stream, List<IResource> images)
{
_stream = stream;
_images = images;

21
WatchFace/Program.cs
View File

@ -3,6 +3,7 @@ using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Reflection;
using BumpKit;
using Newtonsoft.Json;
@ -14,6 +15,7 @@ using Resources.Models;
using WatchFace.Parser;
using WatchFace.Parser.Models;
using WatchFace.Parser.Utils;
using Image = System.Drawing.Image;
using Reader = WatchFace.Parser.Reader;
using Writer = WatchFace.Parser.Writer;
@ -132,11 +134,10 @@ namespace WatchFace
var watchFace = ParseResources(reader);
if (watchFace == null) return;
GeneratePreviews(reader.Parameters, reader.Images.ToArray(), outputDirectory, baseName);
GeneratePreviews(reader.Parameters, reader.Images, outputDirectory, baseName);
Logger.Debug("Exporting resources to '{0}'", outputDirectory);
var reDescriptor = new FileDescriptor {Images = reader.Images};
var reDescriptor = new FileDescriptor {Resources = reader.Resources};
new Extractor(reDescriptor).Extract(outputDirectory);
ExportWatchFaceConfig(watchFace, Path.Combine(outputDirectory, $"{baseName}.json"));
}
@ -173,13 +174,13 @@ namespace WatchFace
}
var i = 0;
var images = new List<Bitmap>();
var images = new List<IResource>();
while (resDescriptor.ResourcesCount == null || i < resDescriptor.ResourcesCount.Value)
{
try
{
var image = ImageLoader.LoadImageForNumber(inputDirectory, i);
images.Add(image);
var resource = ImageLoader.LoadResourceForNumber(inputDirectory, i);
images.Add(resource);
}
catch (FileNotFoundException)
{
@ -194,7 +195,7 @@ namespace WatchFace
throw new ArgumentException(
$"The .res-file should contain {resDescriptor.ResourcesCount.Value} images but was loaded {images.Count} images.");
resDescriptor.Images = images;
resDescriptor.Resources = images;
using (var stream = File.OpenWrite(outputFileName))
{
@ -223,19 +224,19 @@ namespace WatchFace
try
{
Logger.Debug("Reading referenced images from '{0}'", imagesDirectory);
var imagesReader = new ImagesLoader(imagesDirectory);
var imagesReader = new ResourcesLoader(imagesDirectory);
imagesReader.Process(watchFace);
Logger.Trace("Building parameters for watch face...");
var descriptor = ParametersConverter.Build(watchFace);
var baseFilename = Path.GetFileNameWithoutExtension(outputFileName);
GeneratePreviews(descriptor, imagesReader.Images.ToArray(), outputDirectory, baseFilename);
GeneratePreviews(descriptor, imagesReader.Images, outputDirectory, baseFilename);
Logger.Debug("Writing watch face to '{0}'", outputFileName);
using (var fileStream = File.OpenWrite(outputFileName))
{
var writer = new Writer(fileStream, imagesReader.Images);
var writer = new Writer(fileStream, imagesReader.Resources);
writer.Write(descriptor);
fileStream.Flush();
}