public static ThrowHeifException ( string message ) : void | ||
message | string | |
return | void |
/// <summary> /// Gets the meta-data bytes. /// </summary> /// <param name="id">The identifier.</param> /// <returns>The meta-data bytes.</returns> /// <exception cref="HeifException"> /// A LibHeif error occurred. /// /// -or- /// /// The meta-data block is larger than 2 GB. /// </exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> public byte[] GetMetadata(HeifItemId id) { VerifyNotDisposed(); ulong size = LibHeifNative.heif_image_handle_get_metadata_size(this.imageHandle, id).ToUInt64(); if (size == 0) { return(null); } if (size > int.MaxValue) { ExceptionUtil.ThrowHeifException(Resources.MetadataBlockLargerThan2Gb); } byte[] metadata = new byte[size]; unsafe { fixed(byte *ptr = metadata) { var error = LibHeifNative.heif_image_handle_get_metadata(this.imageHandle, id, ptr); error.ThrowIfError(); } } return(metadata); }
/// <summary> /// Gets a list of the thumbnail image ids. /// </summary> /// <returns>A list of the thumbnail image ids.</returns> /// <exception cref="HeifException">Could not get all of the thumbnail image ids.</exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> public IReadOnlyList <HeifItemId> GetThumbnailImageIds() { VerifyNotDisposed(); int count = LibHeifNative.heif_image_handle_get_number_of_thumbnails(this.imageHandle); if (count == 0) { return(Array.Empty <HeifItemId>()); } var ids = new HeifItemId[count]; unsafe { fixed(HeifItemId *ptr = ids) { int filledCount = LibHeifNative.heif_image_handle_get_list_of_thumbnail_IDs(this.imageHandle, ptr, count); if (filledCount != count) { ExceptionUtil.ThrowHeifException(Resources.CannotGetAllThumbnailIds); } } } return(ids); }
internal unsafe SafeHeifDecodingOptions CreateDecodingOptions() { var decodingOptions = LibHeifNative.heif_decoding_options_alloc(); if (decodingOptions.IsInvalid) { ExceptionUtil.ThrowHeifException(Properties.Resources.HeifDecodingOptionsCreationFailed); } byte version = Marshal.ReadByte(decodingOptions.DangerousGetHandle()); if (version >= 2) { var options = (DecodeOptionsVersion2 *)decodingOptions.DangerousGetHandle(); options->ignore_transformations = (byte)(this.IgnoreTransformations ? 1 : 0); options->convert_hdr_to_8bit = (byte)(this.ConvertHdrToEightBit ? 1 : 0); } else { var options = (DecodeOptionsVersion1 *)decodingOptions.DangerousGetHandle(); options->ignore_transformations = (byte)(this.IgnoreTransformations ? 1 : 0); } return(decodingOptions); }
/// <summary> /// Create a <see cref="HeifIccColorProfile"/> from the specified image handle. /// </summary> /// <param name="handle">The handle.</param> /// <returns>The created profile.</returns> /// <exception cref="HeifException"> /// A LibHeif error occurred. /// /// -or- /// /// The ICC profile is larger than 2 GB. /// </exception> internal static unsafe HeifIccColorProfile TryCreate(SafeHeifImageHandle handle) { HeifIccColorProfile profile = null; ulong iccProfileSize = LibHeifNative.heif_image_handle_get_raw_color_profile_size(handle).ToUInt64(); if (iccProfileSize > 0) { if (iccProfileSize > int.MaxValue) { ExceptionUtil.ThrowHeifException(Resources.IccProfileLargerThan2Gb); } byte[] iccProfileBytes = new byte[iccProfileSize]; fixed(byte *ptr = iccProfileBytes) { var error = LibHeifNative.heif_image_handle_get_raw_color_profile(handle, ptr); error.ThrowIfError(); } profile = new HeifIccColorProfile(iccProfileBytes, copyToNewArray: false); } return(profile); }
/// <summary> /// Gets a list of the meta-data block ids. /// </summary> /// <param name="type">The meta-data block type.</param> /// <param name="contentType">The meta-data block content type.</param> /// <returns>A list of the meta-data block ids.</returns> /// <exception cref="HeifException">Could not get all of the meta-data block ids.</exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> public IReadOnlyList <HeifItemId> GetMetadataBlockIds(string type = null, string contentType = null) { VerifyNotDisposed(); int count = LibHeifNative.heif_image_handle_get_number_of_metadata_blocks(this.imageHandle, type); if (count == 0) { return(Array.Empty <HeifItemId>()); } var ids = new HeifItemId[count]; unsafe { fixed(HeifItemId *ptr = ids) { int filledCount = LibHeifNative.heif_image_handle_get_list_of_metadata_block_IDs(this.imageHandle, type, ptr, count); if (filledCount != count) { ExceptionUtil.ThrowHeifException(Resources.CannotGetAllMetadataBlockIds); } } } // The type must be defined in order to filter by content type. if (type != null && contentType != null) { var matchingItems = new List <HeifItemId>(); for (int i = 0; i < ids.Length; i++) { var id = ids[i]; var metadataContentType = LibHeifNative.heif_image_handle_get_metadata_content_type(this.imageHandle, id); if (contentType.Equals(metadataContentType.GetStringValue(), StringComparison.Ordinal)) { matchingItems.Add(id); } } return(matchingItems); } else { return(ids); } }
/// <summary> /// Creates the encoding options. /// </summary> /// <returns>The encoding options.</returns> /// <exception cref="HeifException">Unable to create the native HeifEncodingOptions.</exception> internal unsafe SafeHeifEncodingOptions CreateEncodingOptions() { var encodingOptions = LibHeifNative.heif_encoding_options_alloc(); if (encodingOptions.IsInvalid) { ExceptionUtil.ThrowHeifException(Properties.Resources.HeifEncodingOptionsCreationFailed); } var options = (EncodingOptionsVersion1 *)encodingOptions.DangerousGetHandle(); options->save_alpha_channel = (byte)(this.SaveAlphaChannel ? 1 : 0); return(encodingOptions); }
/// <summary> /// Gets the image data for the specified plane. /// </summary> /// <param name="channel">The channel.</param> /// <returns>The image plane data.</returns> /// <exception cref="HeifException">The image does not contain the specified channel.</exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> public HeifPlaneData GetPlane(HeifChannel channel) { VerifyNotDisposed(); if (!LibHeifNative.heif_image_has_channel(this.image, channel)) { ExceptionUtil.ThrowHeifException(Resources.ImageDoesNotContainChannel); } int width = LibHeifNative.heif_image_get_width(this.image, channel); int height = LibHeifNative.heif_image_get_height(this.image, channel); var scan0 = LibHeifNative.heif_image_get_plane(this.image, channel, out int stride); if (scan0 == IntPtr.Zero || width == -1 || height == -1) { ExceptionUtil.ThrowHeifException(Resources.ImageDoesNotContainChannel); } return(new HeifPlaneData(width, height, stride, channel, scan0)); }
/// <summary> /// Gets a list of the auxiliary image ids. /// </summary> /// <returns>A list of the auxiliary image ids.</returns> /// <exception cref="HeifException">A LibHeif error occurred.</exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> /// <remarks> /// <para>The alpha and/or depth images are omitted from this list.</para> /// <para> /// LibHeif will include the alpha image (if present) when you call <see cref="Decode(HeifColorspace, HeifChroma, HeifDecodingOptions)"/> /// with the <see cref="HeifChroma"/> parameter set to one of the <c>InterleavedRgba</c> values. /// </para> /// <para> /// To read the depth images use <see cref="GetDepthImageIds"/> to get a list of the depth image item ids and /// <see cref="GetDepthImage(HeifItemId)"/> to convert the item id to a <see cref="HeifImageHandle"/>. /// </para> /// </remarks> /// <seealso cref="GetAuxiliaryImage(HeifItemId)"/> /// <seealso cref="GetAuxiliaryType"/> public IReadOnlyList <HeifItemId> GetAuxiliaryImageIds() { VerifyNotDisposed(); if (LibHeifVersion.Is1Point11OrLater) { const heif_auxiliary_image_filter filter = heif_auxiliary_image_filter.OmitAlpha | heif_auxiliary_image_filter.OmitDepth; int count = LibHeifNative.heif_image_handle_get_number_of_auxiliary_images(this.imageHandle, filter); if (count == 0) { return(Array.Empty <HeifItemId>()); } var ids = new HeifItemId[count]; unsafe { fixed(HeifItemId *ptr = ids) { int filledCount = LibHeifNative.heif_image_handle_get_list_of_auxiliary_image_IDs(this.imageHandle, filter, ptr, count); if (filledCount != count) { ExceptionUtil.ThrowHeifException(Resources.CannotGetAllAuxillaryImages); } } } return(ids); } else { return(Array.Empty <HeifItemId>()); } }
/// <summary> /// Initializes a new instance of the <see cref="HeifIccColorProfile"/> class. /// </summary> /// <param name="handle">The handle.</param> /// <exception cref="HeifException"> /// A LibHeif error occurred. /// /// -or- /// /// The ICC profile is zero bytes. /// /// -or- /// /// The ICC profile is larger than 2 GB. /// </exception> internal unsafe HeifIccColorProfile(SafeHeifImageHandle handle) : base(ColorProfileType.Icc) { ulong iccProfileSize = LibHeifNative.heif_image_handle_get_raw_color_profile_size(handle).ToUInt64(); if (iccProfileSize == 0) { ExceptionUtil.ThrowHeifException(Resources.IccProfileZeroBytes); } else if (iccProfileSize > int.MaxValue) { ExceptionUtil.ThrowHeifException(Resources.IccProfileLargerThan2Gb); } this.iccProfileBytes = new byte[iccProfileSize]; fixed(byte *ptr = this.iccProfileBytes) { var error = LibHeifNative.heif_image_handle_get_raw_color_profile(handle, ptr); error.ThrowIfError(); } }