src/Tizen.Multimedia.Util/ImageUtil/ImageDecoder.cs

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18 using System.Collections.Generic;
  19 using System.Diagnostics;
  20 using System.IO;
  21 using System.Linq;
  22 using System.Runtime.InteropServices;
  23 using System.Threading.Tasks;
  24 using static Interop;
  25 using static Interop.Decode;
  26
  27 namespace Tizen.Multimedia.Util
  28 {
  29     /// <summary>
  30     /// This is a base class for image decoders.
  31     /// </summary>
  32     public abstract class ImageDecoder : IDisposable
  33     {
  34         private ImageDecoderHandle _handle;
  35
  36         private ColorSpace? _colorSpace;
  37
  38         internal ImageDecoder(ImageFormat format)
  39         {
  40             Create(out _handle).ThrowIfFailed("Failed to create ImageDecoder");
  41
  42             Debug.Assert(_handle != null);
  43
  44             InputFormat = format;
  45         }
  46
  47         /// <summary>
  48         /// Gets the image format of this decoder.
  49         /// </summary>
  50         public ImageFormat InputFormat { get; }
  51
  52         private ImageDecoderHandle Handle
  53         {
  54             get
  55             {
  56                 if (_handle.IsInvalid)
  57                 {
  58                     throw new ObjectDisposedException(nameof(ImageDecoder));
  59                 }
  60                 return _handle;
  61             }
  62         }
  63
  64         /// <summary>
  65         /// Sets the color-space to decode into. The default is <see cref="ColorSpace.Rgba8888"/>.
  66         /// </summary>
  67         /// <param name="colorSpace">The value indicating color-space to decode into.</param>
  68         /// <exception cref="ArgumentException"><paramref name="colorSpace"/> is invalid.</exception>
  69         /// <exception cref="NotSupportedException"><paramref name="colorSpace"/> is not supported by the decoder.</exception>
  70         /// <seealso cref="ImageUtil.GetSupportedColorSpaces(ImageFormat)"/>
  71         public void SetColorSpace(ColorSpace colorSpace)
  72         {
  73             ValidationUtil.ValidateEnum(typeof(ColorSpace), colorSpace, nameof(ColorSpace));
  74
  75             if (ImageUtil.GetSupportedColorSpaces(InputFormat).Contains(colorSpace) == false)
  76             {
  77                 throw new NotSupportedException($"{colorSpace.ToString()} is not supported for {InputFormat}.");
  78             }
  79
  80             _colorSpace = colorSpace;
  81         }
  82
  83         /// <summary>
  84         /// Decodes an image from the specified file.
  85         /// </summary>
  86         /// <param name="inputFilePath">The input file path from which to decode.</param>
  87         /// <returns>A task that represents the asynchronous decoding operation.</returns>
  88         /// <remarks>
  89         ///     Only Graphics Interchange Format(GIF) codec returns more than one frame.\n
  90         ///     \n
  91         ///     http://tizen.org/privilege/mediastorage is needed if <paramref name="inputFilePath"/> is relevant to the media storage.\n
  92         ///     http://tizen.org/privilege/externalstorage is needed if <paramref name="inputFilePath"/> is relevant to the external storage.
  93         /// </remarks>
  94         /// <exception cref="ArgumentNullException"><paramref name="inputFilePath"/> is null.</exception>
  95         /// <exception cref="ArgumentException">
  96         ///     <paramref name="inputFilePath"/> is an empty string.\n
  97         ///     - or -\n
  98         ///     <paramref name="inputFilePath"/> is not a image file.\n
  99         ///     - or -\n
 100         ///     The format of <paramref name="inputFilePath"/> is not <see cref="InputFormat"/>.
 101         /// </exception>
 102         /// <exception cref="FileNotFoundException"><paramref name="inputFilePath"/> does not exists.</exception>
 103         /// <exception cref="UnauthorizedAccessException">The caller does not have required permission to access the path.</exception>
 104         /// <exception cref="FileFormatException">The format of <paramref name="inputFilePath"/> is not <see cref="InputFormat"/>.</exception>
 105         /// <exception cref="ObjectDisposedException">The <see cref="ImageDecoder"/> has already been disposed of.</exception>
 106         public async Task<IEnumerable<BitmapFrame>> DecodeAsync(string inputFilePath)
 107         {
 108             if (inputFilePath == null)
 109             {
 110                 throw new ArgumentNullException(nameof(inputFilePath));
 111             }
 112
 113             if (inputFilePath.Length == 0)
 114             {
 115                 throw new ArgumentException("path is empty.", nameof(inputFilePath));
 116             }
 117
 118             if (CheckHeader(inputFilePath) == false)
 119             {
 120                 throw new FileFormatException("The file has an invalid header.");
 121             }
 122
 123             var pathPtr = Marshal.StringToHGlobalAnsi(inputFilePath);
 124             try
 125             {
 126
 127                 SetInputPath(Handle, pathPtr).ThrowIfFailed("Failed to set input file path for decoding");
 128                 return await DecodeAsync();
 129             }
 130             finally
 131             {
 132                 Marshal.FreeHGlobal(pathPtr);
 133             }
 134         }
 135
 136         /// <summary>
 137         /// Decodes an image from the buffer.
 138         /// </summary>
 139         /// <param name="inputBuffer">The image buffer from which to decode.</param>
 140         /// <returns>A task that represents the asynchronous decoding operation.</returns>
 141         /// <remarks>
 142         ///     Only Graphics Interchange Format(GIF) codec returns more than one frame.\n
 143         /// </remarks>
 144         /// <exception cref="ArgumentNullException"><paramref name="inputBuffer"/> is null.</exception>
 145         /// <exception cref="ArgumentException">
 146         ///     <paramref name="inputBuffer"/> is an empty array.\n
 147         ///     - or -\n
 148         ///     The format of <paramref name="inputBuffer"/> is not <see cref="InputFormat"/>.
 149         /// </exception>
 150         /// <exception cref="FileFormatException">The format of <paramref name="inputBuffer"/> is not <see cref="InputFormat"/>.</exception>
 151         /// <exception cref="ObjectDisposedException">The <see cref="ImageDecoder"/> has already been disposed of.</exception>
 152         public Task<IEnumerable<BitmapFrame>> DecodeAsync(byte[] inputBuffer)
 153         {
 154             if (inputBuffer == null)
 155             {
 156                 throw new ArgumentNullException(nameof(inputBuffer));
 157             }
 158
 159             if (inputBuffer.Length == 0)
 160             {
 161                 throw new ArgumentException("buffer is empty.", nameof(inputBuffer));
 162             }
 163
 164             if (CheckHeader(inputBuffer) == false)
 165             {
 166                 throw new FileFormatException("buffer has an invalid header.");
 167             }
 168
 169             SetInputBuffer(Handle, inputBuffer, (ulong)inputBuffer.Length).
 170                 ThrowIfFailed("Failed to set input buffer for decoding");
 171
 172             return DecodeAsync();
 173         }
 174
 175         private bool CheckHeader(byte[] input)
 176         {
 177             if (input.Length < Header.Length)
 178             {
 179                 return false;
 180             }
 181
 182             for (int i = 0; i < Header.Length; ++i)
 183             {
 184                 if (input[i] != Header[i])
 185                 {
 186                     return false;
 187                 }
 188             }
 189
 190             return true;
 191         }
 192
 193         private bool CheckHeader(string inputFile)
 194         {
 195             using (var fs = File.OpenRead(inputFile))
 196             {
 197                 byte[] fileHeader = new byte[Header.Length];
 198
 199                 if (fs.Read(fileHeader, 0, fileHeader.Length) < Header.Length)
 200                 {
 201                     return false;
 202                 }
 203                 return CheckHeader(fileHeader);
 204             }
 205         }
 206
 207         internal Task<IEnumerable<BitmapFrame>> DecodeAsync()
 208         {
 209             Initialize(Handle);
 210
 211             IntPtr outBuffer = IntPtr.Zero;
 212             SetOutputBuffer(Handle, out outBuffer).ThrowIfFailed("Failed to decode given image");
 213
 214             var tcs = new TaskCompletionSource<IEnumerable<BitmapFrame>>();
 215
 216             Task.Run(() =>
 217             {
 218                 try
 219                 {
 220                     int width, height;
 221                     ulong size;
 222
 223                     DecodeRun(Handle, out width, out height, out size).ThrowIfFailed("Failed to decode");
 224
 225                     tcs.SetResult(new[] { new BitmapFrame(outBuffer, width, height, (int)size) });
 226                 }
 227                 catch (Exception e)
 228                 {
 229                     tcs.TrySetException(e);
 230                 }
 231                 finally
 232                 {
 233                     LibcSupport.Free(outBuffer);
 234                 }
 235             });
 236
 237             return tcs.Task;
 238         }
 239
 240         internal virtual void Initialize(ImageDecoderHandle handle)
 241         {
 242             if (_colorSpace.HasValue)
 243             {
 244                 SetColorspace(Handle, _colorSpace.Value.ToImageColorSpace()).ThrowIfFailed("Failed to set color space");
 245             }
 246         }
 247
 248         internal abstract byte[] Header { get; }
 249
 250         #region IDisposable Support
 251         private bool _disposed = false;
 252
 253         /// <summary>
 254         /// Releases the unmanaged resources used by the ImageDecoder.
 255         /// </summary>
 256         /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
 257         protected virtual void Dispose(bool disposing)
 258         {
 259             if (!_disposed)
 260             {
 261                 if (_handle != null)
 262                 {
 263                     _handle.Dispose();
 264                 }
 265                 _disposed = true;
 266             }
 267         }
 268
 269         /// <summary>
 270         /// Releases all resources used by the ImageDecoder.
 271         /// </summary>
 272         public void Dispose()
 273         {
 274             Dispose(true);
 275         }
 276         #endregion
 277     }
 278
 279     /// <summary>
 280     /// Provides the ability to decode Bitmap (BMP) encoded images.
 281     /// </summary>
 282     public class BmpDecoder : ImageDecoder
 283     {
 284         private static readonly byte[] _header = { (byte)'B', (byte)'M' };
 285
 286         /// <summary>
 287         /// Initializes a new instance of the <see cref="BmpDecoder"/> class.
 288         /// </summary>
 289         /// <remarks><see cref="ImageDecoder.InputFormat"/> will be the <see cref="ImageFormat.Bmp"/>.</remarks>
 290         public BmpDecoder() : base(ImageFormat.Bmp)
 291         {
 292         }
 293
 294         internal override byte[] Header => _header;
 295     }
 296
 297     /// <summary>
 298     /// Provides the ability to decode the Portable Network Graphics (PNG) encoded images.
 299     /// </summary>
 300     public class PngDecoder : ImageDecoder
 301     {
 302         private static readonly byte[] _header = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
 303
 304         /// <summary>
 305         /// Initializes a new instance of the <see cref="PngDecoder"/> class.
 306         /// </summary>
 307         /// <remarks><see cref="ImageDecoder.InputFormat"/> will be the <see cref="ImageFormat.Png"/>.</remarks>
 308         public PngDecoder() : base(ImageFormat.Png)
 309         {
 310         }
 311
 312         internal override byte[] Header => _header;
 313     }
 314
 315     /// <summary>
 316     /// Provides the ability to decode the Joint Photographic Experts Group (JPEG) encoded images.
 317     /// </summary>
 318     public class JpegDecoder : ImageDecoder
 319     {
 320         private static readonly byte[] _header = { 0xFF, 0xD8 };
 321
 322         /// <summary>
 323         /// A read-only field that represents the default value of <see cref="Downscale"/>.
 324         /// </summary>
 325         public static readonly JpegDownscale DefaultJpegDownscale = JpegDownscale.None;
 326
 327         private JpegDownscale _jpegDownscale = DefaultJpegDownscale;
 328
 329         /// <summary>
 330         /// Initializes a new instance of the <see cref="JpegDecoder"/> class.
 331         /// </summary>
 332         /// <remarks><see cref="ImageDecoder.InputFormat"/> will be the <see cref="ImageFormat.Jpeg"/>.</remarks>
 333         public JpegDecoder() : base(ImageFormat.Jpeg)
 334         {
 335         }
 336
 337         /// <summary>
 338         /// Gets or sets the downscale at which the jpeg image should be decoded.
 339         /// </summary>
 340         /// <exception cref="ArgumentException"><paramref name="value"/> is invalid.</exception>
 341         public JpegDownscale Downscale
 342         {
 343             get
 344             {
 345                 return _jpegDownscale;
 346             }
 347             set
 348             {
 349                 ValidationUtil.ValidateEnum(typeof(JpegDownscale), value, nameof(Downscale));
 350
 351                 _jpegDownscale = value;
 352             }
 353         }
 354
 355         internal override void Initialize(ImageDecoderHandle handle)
 356         {
 357             base.Initialize(handle);
 358
 359             SetJpegDownscale(handle, Downscale).ThrowIfFailed("Failed to set downscale for decoding");
 360         }
 361
 362         internal override byte[] Header => _header;
 363     }
 364
 365     /// <summary>
 366     /// Provides the ability to decode the Graphics Interchange Format (GIF) encoded images.
 367     /// </summary>
 368     public class GifDecoder : ImageDecoder
 369     {
 370         private static readonly byte[] _header = { (byte)'G', (byte)'I', (byte)'F' };
 371
 372         /// <summary>
 373         /// Initializes a new instance of the <see cref="GifDecoder"/> class.
 374         /// </summary>
 375         /// <remarks><see cref="ImageDecoder.InputFormat"/> will be the <see cref="ImageFormat.Gif"/>.</remarks>
 376         public GifDecoder() : base(ImageFormat.Gif)
 377         {
 378         }
 379
 380         internal override byte[] Header => _header;
 381     }
 382 }