/// <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); }
/// <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 the depth representation information. /// </summary> /// <param name="id">The depth image id.</param> /// <returns>The depth representation information.</returns> /// <exception cref="HeifException">A LibHeif error occurred.</exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> public HeifDepthRepresentationInfo GetDepthRepresentationInfo(HeifItemId id) { VerifyNotDisposed(); HeifDepthRepresentationInfo depthRepresentationInfo = null; SafeDepthRepresentationInfo safeDepthRepresentationInfo = null; try { if (LibHeifNative.heif_image_handle_get_depth_image_representation_info(this.imageHandle, id, out safeDepthRepresentationInfo)) { unsafe { var info = (heif_depth_representation_info *)safeDepthRepresentationInfo.DangerousGetHandle(); depthRepresentationInfo = new HeifDepthRepresentationInfo(info); } } } finally { safeDepthRepresentationInfo?.Dispose(); } return(depthRepresentationInfo); }
/// <summary> /// Gets the auxiliary image handle. /// </summary> /// <param name="id">The auxiliary image id.</param> /// <returns>The auxiliary image handle.</returns> /// <exception cref="HeifException">A LibHeif error occurred.</exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> /// <seealso cref="GetAuxiliaryImageIds"/> public HeifImageHandle GetAuxiliaryImage(HeifItemId id) { VerifyNotDisposed(); if (LibHeifVersion.Is1Point11OrLater) { HeifImageHandle aux = null; SafeHeifImageHandle auxSafeHandle = null; try { var error = LibHeifNative.heif_image_handle_get_auxiliary_image_handle(this.imageHandle, id, out auxSafeHandle); error.ThrowIfError(); aux = new HeifImageHandle(auxSafeHandle, this.decodeErrorHandler, AuxiliaryImageType.VendorSpecific); auxSafeHandle = null; } finally { auxSafeHandle?.Dispose(); } return(aux); } else { throw new HeifException(Resources.AuxiliaryImageAPINotSupported); } }
/// <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> /// 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> /// Gets the thumbnail image handle. /// </summary> /// <param name="id">The thumbnail image id.</param> /// <returns>The thumbnail image handle.</returns> /// <exception cref="HeifException">A LibHeif error occurred.</exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> public HeifImageHandle GetThumbnailImage(HeifItemId id) { VerifyNotDisposed(); HeifImageHandle thumbnail = null; SafeHeifImageHandle thumbnailSafeHandle = null; try { var error = LibHeifNative.heif_image_handle_get_thumbnail(this.imageHandle, id, out thumbnailSafeHandle); error.ThrowIfError(); thumbnail = new HeifImageHandle(thumbnailSafeHandle, this.decodeErrorHandler); thumbnailSafeHandle = null; } finally { thumbnailSafeHandle?.Dispose(); } return(thumbnail); }
/// <summary> /// Gets the depth images. /// </summary> /// <param name="id">The depth image id.</param> /// <returns>The meta-data bytes.</returns> /// <exception cref="HeifException">A LibHeif error occurred.</exception> /// <exception cref="ObjectDisposedException">The object has been disposed.</exception> public HeifImageHandle GetDepthImage(HeifItemId id) { VerifyNotDisposed(); HeifImageHandle depth = null; SafeHeifImageHandle depthSafeHandle = null; try { var error = LibHeifNative.heif_image_handle_get_depth_image_handle(this.imageHandle, id, out depthSafeHandle); error.ThrowIfError(); depth = new HeifImageHandle(depthSafeHandle, this.decodeErrorHandler); depthSafeHandle = null; } finally { depthSafeHandle?.Dispose(); } return(depth); }