Uno.SkiaSharp/tests/Tests/SKCodecTest.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using Xunit;

namespace SkiaSharp.Tests
{
	public class SKCodecTest : SKTest
	{
		[SkippableFact]
		public void MinBufferedBytesNeededHasAValue ()
		{
			Assert.True (SKCodec.MinBufferedBytesNeeded > 0);
		}

		[SkippableFact]
		public unsafe void StreamLosesOwnershipTddoCodecButIsNotForgotten()
		{
			var codec = SKCodec.Create(Path.Combine(PathToImages, "color-wheel.png"));

			for (var i = 0; i < 1000; ++i)
			{
				Assert.Equal(SKCodecResult.Success, codec.GetPixels(out _));
			}
		}

		[SkippableFact]
		public unsafe void ReleaseDataWasInvokedOnlyAfterTheCodecWasFinished()
		{
			var path = Path.Combine(PathToImages, "color-wheel.png");
			var bytes = File.ReadAllBytes(path);

			var released = false;

			fixed (byte* b = bytes)
			{
				var data = SKData.Create((IntPtr)b, bytes.Length, (addr, ctx) => released = true);

				var codec = SKCodec.Create(data);
				Assert.NotEqual(SKImageInfo.Empty, codec.Info);

				data.Dispose();
				Assert.False(released, "The SKDataReleaseDelegate was called too soon.");

				codec.Dispose();
				Assert.True(released, "The SKDataReleaseDelegate was not called at all.");
			}
		}

		[SkippableFact]
		public unsafe void StreamLosesOwnershipToCodecButIsNotForgotten()
		{
			var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "color-wheel.png"));
			var stream = new SKMemoryStream(bytes);
			var handle = stream.Handle;

			Assert.True(stream.OwnsHandle);
			Assert.True(SKObject.GetInstance<SKMemoryStream>(handle, out _));

			var codec = SKCodec.Create(stream);
			Assert.False(stream.OwnsHandle);

			stream.Dispose();
			Assert.True(SKObject.GetInstance<SKMemoryStream>(handle, out _));

			Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels));
			Assert.NotEmpty(pixels);
		}

		[SkippableFact]
		public unsafe void StreamLosesOwnershipAndCanBeDisposedButIsNotActually()
		{
			var path = Path.Combine(PathToImages, "color-wheel.png");
			var stream = new SKMemoryStream(File.ReadAllBytes(path));
			var handle = stream.Handle;

			Assert.True(stream.OwnsHandle);
			Assert.False(stream.IgnorePublicDispose);
			Assert.True(SKObject.GetInstance<SKMemoryStream>(handle, out _));

			var codec = SKCodec.Create(stream);
			Assert.False(stream.OwnsHandle);
			Assert.True(stream.IgnorePublicDispose);

			stream.Dispose();
			Assert.True(SKObject.GetInstance<SKMemoryStream>(handle, out var inst));
			Assert.Same(stream, inst);

			Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels));
			Assert.NotEmpty(pixels);

			codec.Dispose();
			Assert.False(SKObject.GetInstance<SKMemoryStream>(handle, out _));
		}

		[SkippableFact]
		public unsafe void InvalidStreamIsDisposedImmediately()
		{
			var stream = CreateTestSKStream();
			var handle = stream.Handle;

			Assert.True(stream.OwnsHandle);
			Assert.False(stream.IgnorePublicDispose);
			Assert.True(SKObject.GetInstance<SKStream>(handle, out _));

			Assert.Null(SKCodec.Create(stream));

			Assert.False(stream.OwnsHandle);
			Assert.True(stream.IgnorePublicDispose);
			Assert.False(SKObject.GetInstance<SKStream>(handle, out _));
		}

		[SkippableFact]
		public unsafe void StreamLosesOwnershipAndCanBeGarbageCollected()
		{
			VerifyImmediateFinalizers();

			var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "color-wheel.png"));

			DoWork(out var codecH, out var streamH);

			CollectGarbage();

			Assert.False(SKObject.GetInstance<SKMemoryStream>(streamH, out _));
			Assert.False(SKObject.GetInstance<SKCodec>(codecH, out _));

			void DoWork(out IntPtr codecHandle, out IntPtr streamHandle)
			{
				var codec = CreateCodec(out streamHandle);
				codecHandle = codec.Handle;

				CollectGarbage();

				Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels));
				Assert.NotEmpty(pixels);

				Assert.True(SKObject.GetInstance<SKMemoryStream>(streamHandle, out var stream));
				Assert.False(stream.OwnsHandle);
				Assert.True(stream.IgnorePublicDispose);
			}

			SKCodec CreateCodec(out IntPtr streamHandle)
			{
				var stream = new SKMemoryStream(bytes);
				streamHandle = stream.Handle;

				Assert.True(stream.OwnsHandle);
				Assert.False(stream.IgnorePublicDispose);
				Assert.True(SKObject.GetInstance<SKMemoryStream>(streamHandle, out _));

				return SKCodec.Create(stream);
			}
		}

		[SkippableFact]
		public void CanCreateStreamCodec()
		{
			var stream = File.OpenRead(Path.Combine(PathToImages, "color-wheel.png"));
			using var codec = SKCodec.Create(stream);

			Assert.Equal(SKEncodedImageFormat.Png, codec.EncodedFormat);
			Assert.Equal(128, codec.Info.Width);
			Assert.Equal(128, codec.Info.Height);
			Assert.Equal(SKAlphaType.Unpremul, codec.Info.AlphaType);
			Assert.Equal(SKImageInfo.PlatformColorType, codec.Info.ColorType);
		}

		[SkippableFact]
		public void CanCreateStreamCodecWithResult()
		{
			var stream = File.OpenRead(Path.Combine(PathToImages, "color-wheel.png"));
			using var codec = SKCodec.Create(stream, out var result);

			Assert.Equal(SKCodecResult.Success, result);
			Assert.Equal(SKEncodedImageFormat.Png, codec.EncodedFormat);
			Assert.Equal(128, codec.Info.Width);
			Assert.Equal(128, codec.Info.Height);
			Assert.Equal(SKAlphaType.Unpremul, codec.Info.AlphaType);
			Assert.Equal(SKImageInfo.PlatformColorType, codec.Info.ColorType);
		}

		[SkippableFact]
		public void GetGifFrames ()
		{
			const int FrameCount = 16;

			var stream = new SKFileStream (Path.Combine (PathToImages, "animated-heart.gif"));
			using (var codec = SKCodec.Create (stream)) {
				Assert.Equal (-1, codec.RepetitionCount);

				var frameInfos = codec.FrameInfo;
				Assert.Equal (FrameCount, frameInfos.Length);

				Assert.Equal (-1, frameInfos [0].RequiredFrame);

				var cachedFrames = new SKBitmap [FrameCount];
				var info = new SKImageInfo (codec.Info.Width, codec.Info.Height);

				var decode = new Action<SKBitmap, int, int> ((bm, cachedIndex, index) => {
					var decodeInfo = info;
					if (index > 0) {
						decodeInfo = info.WithAlphaType (frameInfos [index].AlphaType);
					}
					Assert.True (bm.TryAllocPixels (decodeInfo));
					if (cachedIndex != -1) {
						Assert.True (cachedFrames [cachedIndex].CopyTo (bm));
					}
					var opts = new SKCodecOptions (index, cachedIndex);
					var result = codec.GetPixels (decodeInfo, bm.GetPixels (), opts);
					if (cachedIndex != -1 && frameInfos [cachedIndex].DisposalMethod == SKCodecAnimationDisposalMethod.RestorePrevious) {
						Assert.Equal (SKCodecResult.InvalidParameters, result);
					}
					Assert.Equal (SKCodecResult.Success, result);
				});

				for (var i = 0; i < FrameCount; i++) {
					var cachedFrame = cachedFrames [i] = new SKBitmap ();
					decode (cachedFrame, -1, i);

					var uncachedFrame = new SKBitmap ();
					decode (uncachedFrame, frameInfos [i].RequiredFrame, i);

					var cachedBytes = cachedFrame.Bytes;
					var uncachedBytes = uncachedFrame.Bytes;
					Assert.Equal (cachedBytes, uncachedBytes);
				}
			}
		}

		[SkippableFact]
		public void GetSingleGifFrame()
		{
			var stream = new SKFileStream(Path.Combine(PathToImages, "animated-heart.gif"));
			using (var codec = SKCodec.Create(stream))
			{
				var frameInfos = codec.FrameInfo;
				for (var i = 0; i < frameInfos.Length; i++)
				{
					Assert.True(codec.GetFrameInfo(i, out var info));
					Assert.Equal(frameInfos[i], info);
				}
			}
		}

		[SkippableFact]
		public void GetEncodedInfo ()
		{
			var stream = new SKFileStream (Path.Combine (PathToImages, "color-wheel.png"));
			using (var codec = SKCodec.Create (stream)) {
				Assert.Equal (SKImageInfo.PlatformColorType, codec.Info.ColorType);
				Assert.Equal (SKAlphaType.Unpremul, codec.Info.AlphaType);
				Assert.Equal (32, codec.Info.BitsPerPixel);
			}
		}

		[SkippableFact]
		public void CanGetPixels ()
		{
			var stream = new SKFileStream (Path.Combine (PathToImages, "baboon.png"));
			using (var codec = SKCodec.Create (stream)) {
				var pixels = codec.Pixels;
				Assert.Equal (codec.Info.BytesSize, pixels.Length);
			}
		}

		[SkippableFact]
		public void DecodeImageScanlines ()
		{
			var path = Path.Combine (PathToImages, "CMYK.jpg");
			var imageHeight = 516;

			var fileData = File.ReadAllBytes (path);
			var correctBitmap = SKBitmap.Decode (path);

			var stream = new SKFileStream (path);
			using (var codec = SKCodec.Create (stream)) {
				var info = new SKImageInfo (codec.Info.Width, codec.Info.Height);
				using (var scanlineBitmap = new SKBitmap (info)) {
					scanlineBitmap.Erase (SKColors.Fuchsia);

					var result = codec.StartScanlineDecode (info);
					Assert.Equal (SKCodecResult.Success, result);

					Assert.Equal (SKCodecScanlineOrder.TopDown, codec.ScanlineOrder);
					Assert.Equal (0, codec.NextScanline);

					// only decode every second line
					for	(int y = 0; y < info.Height; y += 2) {
						Assert.Equal (1, codec.GetScanlines (scanlineBitmap.GetAddress (0, y), 1, info.RowBytes));
						Assert.Equal (y + 1, codec.NextScanline);
						if (codec.SkipScanlines (1))
							Assert.Equal (y + 2, codec.NextScanline);
						else
							Assert.Equal (imageHeight, codec.NextScanline); // reached the end
					}

					Assert.False (codec.SkipScanlines (1));
					Assert.Equal (imageHeight, codec.NextScanline);

					for (var x = 0; x < info.Width; x++) {
						for (var y = 0; y < info.Height; y++) {
							if (y % 2 == 0)
								Assert.Equal (correctBitmap.GetPixel (x, y), scanlineBitmap.GetPixel (x, y));
							else
								Assert.Equal (SKColors.Fuchsia, scanlineBitmap.GetPixel (x, y));
						}
					}
				}
			}
		}

		[SkippableFact]
		public void DecodePartialImage ()
		{
			// read the data here, so we can fake a throttle/download
			var path = Path.Combine (PathToImages, "baboon.png");
			var fileData = File.ReadAllBytes (path);
			SKColor[] correctBytes;
			using (var bitmap = SKBitmap.Decode (path)) {
				correctBytes = bitmap.Pixels;
			}

			int offset = 0;
			int maxCount = 1024 * 4;

			// the "download" stream needs some data
			var downloadStream = new MemoryStream ();
			downloadStream.Write (fileData, offset, maxCount);
			downloadStream.Position -= maxCount;
			offset += maxCount;

			using (var codec = SKCodec.Create (new SKManagedStream (downloadStream))) {
				var info = new SKImageInfo (codec.Info.Width, codec.Info.Height);

				// the bitmap to be decoded
				using (var incremental = new SKBitmap (info)) {

					// start decoding
					IntPtr length;
					var pixels = incremental.GetPixels (out length);
					var result = codec.StartIncrementalDecode (info, pixels, info.RowBytes);

					// make sure the start was successful
					Assert.Equal (SKCodecResult.Success, result);
					result = SKCodecResult.IncompleteInput;

					while (result == SKCodecResult.IncompleteInput) {
						// decode the rest
						int rowsDecoded = 0;
						result = codec.IncrementalDecode (out rowsDecoded);

						// write some more data to the stream
						maxCount = Math.Min (maxCount, fileData.Length - offset);
						downloadStream.Write (fileData, offset, maxCount);
						downloadStream.Position -= maxCount;
						offset += maxCount;
					}

					// compare to original
					Assert.Equal (correctBytes, incremental.Pixels);
				}
			}
		}

		[SkippableFact]
		public void BitmapDecodesCorrectly ()
		{
			byte[] codecPixels;
			byte[] bitmapPixels;

			using (var codec = SKCodec.Create (new SKFileStream (Path.Combine (PathToImages, "baboon.png")))) {
				codecPixels = codec.Pixels;
			}

			using (var bitmap = SKBitmap.Decode (Path.Combine (PathToImages, "baboon.png"))) {
				bitmapPixels = bitmap.Bytes;
			}

			Assert.Equal (codecPixels, bitmapPixels);
		}

		[SkippableFact]
		public void BitmapDecodesCorrectlyWithManagedStream ()
		{
			byte[] codecPixels;
			byte[] bitmapPixels;

			var stream = File.OpenRead (Path.Combine(PathToImages, "baboon.png"));
			using (var codec = SKCodec.Create (new SKManagedStream (stream))) {
				codecPixels = codec.Pixels;
			}

			using (var bitmap = SKBitmap.Decode (Path.Combine (PathToImages, "baboon.png"))) {
				bitmapPixels = bitmap.Bytes;
			}

			Assert.Equal (codecPixels, bitmapPixels);
		}

		[SkippableFact]
		public void CanReadManagedStream()
		{
			using (var stream = File.OpenRead(Path.Combine(PathToImages, "baboon.png")))
			using (var codec = SKCodec.Create(stream))
				Assert.NotNull(codec);
		}

		[SkippableFact (Skip = "This keeps breaking CI for some reason.")]
		public async Task DownloadedStream ()
		{
			var httpClient = new HttpClient ();
			using (var stream = await httpClient.GetStreamAsync (new Uri ("http://www.gstatic.com/webp/gallery/2.webp")))
			using (var bitmap = SKBitmap.Decode (stream))
				Assert.NotNull (bitmap);
		}

		[SkippableFact]
		public void ReadOnlyStream ()
		{
			using (var stream = File.OpenRead (Path.Combine (PathToImages, "baboon.png")))
			using (var nonSeekable = new NonSeekableReadOnlyStream (stream))
			using (var bitmap = SKBitmap.Decode (nonSeekable))
				Assert.NotNull (bitmap);
		}

		[SkippableTheory]
		[InlineData("CMYK.jpg")]
		[InlineData("baboon.png")]
		[InlineData("color-wheel.png")]
		public void CanDecodePath(string image)
		{
			var path = Path.Combine(PathToImages, image);

			using var codec = SKCodec.Create(path);
			Assert.NotNull(codec);

			Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels));
			Assert.NotEmpty(pixels);
		}

		[SkippableTheory]
		[InlineData("CMYK.jpg")]
		[InlineData("baboon.png")]
		[InlineData("color-wheel.png")]
		public void CanDecodeData(string image)
		{
			var path = Path.Combine(PathToImages, image);

			using var data = SKData.Create(path);
			Assert.NotNull(data);

			using var codec = SKCodec.Create(data);
			Assert.NotNull(codec);

			Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels));
			Assert.NotEmpty(pixels);
		}
	}
}