Exemple #1
0
        public virtual void Storage_InputStreamStoringInMostSignifcantBit()
        {
            byte[] embeddedData = { 100, 200, 250, 0, 5, 6, 10, 99 };
            PixelStorageOptions storageOptions =
                new PixelStorageOptions(new[]
            {
                new PixelStorageOptions.ChannelStorageOptions(1,
                                                              PixelStorageOptions.BitStorageMode.MostSignificantBits),
            });

            var outputStream = new MemoryStream();

            using (Stream pixelWriterStream = new PixelStorageWriterStream(outputStream, new MemoryStream(embeddedData), storageOptions, false))
            {
                pixelWriterStream.WriteByte(255);

                byte[] output = outputStream.ToArray();
                CollectionAssert.AreEqual(
                    new byte[] { 228, 200, 250, 128, 133, 134, 138, 227 },
                    output);

                using (Stream imageReaderStream = new PixelStorageReaderStream(new MemoryStream(output), storageOptions, false))
                {
                    var decodedData = new MemoryStream();
                    imageReaderStream.CopyTo(decodedData);
                    CollectionAssert.AreEqual(new byte[] { 255 }, decodedData.ToArray());
                }
            }
        }
Exemple #2
0
        public virtual async Task Storage_InputStreamThenOuputStreamProducesEquivalentData(Stream testData, PixelStorageOptions pixelStorageOptions, Stream image)
        {
            testData.Position = 0;
            var originalDataStream = new MemoryStream();
            await testData.CopyToAsync(originalDataStream);

            originalDataStream.Position = 0;

            var pixelDataStream = new MemoryStream();

            byte[] paddingBytes;
            using (var pixelWriterStream = new PixelStorageWriterStream(pixelDataStream, image, pixelStorageOptions, true))
            {
                paddingBytes = new byte[pixelWriterStream.BytesPerUnit - originalDataStream.Length % pixelWriterStream.BytesPerUnit];
                // Use an uneven write size to ensure remainder bytes are handled properly
                while (originalDataStream.Length != originalDataStream.Position)
                {
                    foreach (int writeSize in writeSizes)
                    {
                        byte[] buffer         = new byte[writeSize];
                        int    totalBytesRead = 0;
                        while (totalBytesRead < writeSize)
                        {
                            int bytesRead =
                                await
                                originalDataStream.ReadAsync(buffer, totalBytesRead,
                                                             buffer.Length - totalBytesRead);

                            if (bytesRead == 0)
                            {
                                break;
                            }
                            totalBytesRead += bytesRead;
                        }

                        await pixelWriterStream.WriteAsync(buffer, 0, totalBytesRead);
                    }
                }

                await pixelWriterStream.WriteAsync(paddingBytes, 0, paddingBytes.Length);
            }

            var decodedData = new MemoryStream();

            pixelDataStream.Position = 0;
            using (var imageReaderStream = new PixelStorageReaderStream(pixelDataStream, pixelStorageOptions, true))
            {
                await imageReaderStream.CopyToAsync(decodedData, 4096);
            }

            byte[] expectedData = originalDataStream.ToArray().Concat(paddingBytes).ToArray();
            var    actualData   = decodedData.ToArray();

            if (!expectedData.SequenceEqual(actualData))
            {
                CollectionAssert.AreEqual(expectedData, actualData);
                Assert.Fail();
            }
        }
        private async Task WriteEmbeddedImagePaddingAsync(PixelStorageWriterStream pixelStorageStream)
        {
            var embeddedImageDataStream = pixelStorageStream.EmbeddedImageDataStream;

            if (pixelStorageStream.BytesLeftInUnit != 0)
            {
                // Pad the final unit of the pixel storage stream
                // Cannot pad with embedded image data stream as the
                // stream will also be read from within the storage stream
                // advancing the image stream too far.
                await pixelStorageStream.WriteAsync(new byte[pixelStorageStream.BytesLeftInUnit], 0, pixelStorageStream.BytesLeftInUnit);
            }

            // Directly copy remaining image data to underlying image stream.
            await new EmbeddedImagePadding(embeddedImageDataStream, EncodingConfiguration.BufferSize)
            .PadDataAsync(pixelStorageStream.ImageFormatterStream);
        }