Beispiel #1
0
        private static byte[] ExtractXMPPacket(BitmapMetadata xmp)
        {
            BitmapMetadata tiffMetaData = new BitmapMetadata("tiff");

            tiffMetaData.SetQuery("/ifd/xmp", new BitmapMetadata("xmp"));

            foreach (string tag in xmp)
            {
                object value = xmp.GetQuery(tag);

                if (value is BitmapMetadata xmpSub)
                {
                    CopySubIFDRecursive(ref tiffMetaData, xmpSub, "/ifd/xmp" + tag);
                }
                else
                {
                    tiffMetaData.SetQuery("/ifd/xmp" + tag, value);
                }
            }

            byte[] xmpBytes = null;

            using (MemoryStream stream = new MemoryStream())
            {
                // Create a dummy tiff to extract the XMP packet from.
                BitmapSource      source  = BitmapSource.Create(1, 1, 96.0, 96.0, PixelFormats.Gray8, null, new byte[] { 255 }, 1);
                TiffBitmapEncoder encoder = new TiffBitmapEncoder();
                encoder.Frames.Add(BitmapFrame.Create(source, null, tiffMetaData, null));
                encoder.Save(stream);

                xmpBytes = TiffReader.ExtractXMP(stream);
            }

            return(xmpBytes);
        }
Beispiel #2
0
        /// <summary>
        /// Extracts the meta data from the image.
        /// </summary>
        /// <param name="bytes">The output bytes.</param>
        /// <param name="exif">set to <c>true</c> if the EXIF data is requested.</param>
        /// <returns><c>true</c> if the meta data was extracted; otherwise, <c>false</c>.</returns>
        /// <exception cref="System.ObjectDisposedException">The object has been disposed.</exception>
        public bool Extract(out byte[] bytes, bool exif)
        {
            if (disposed)
            {
                throw new ObjectDisposedException(nameof(ImageMetaData));
            }

            bytes = null;

            // Return the cached data if it has already been extracted.
            if (exif)
            {
                if (extractedExif)
                {
                    bytes = exifBytes;
                    return(bytes != null);
                }
            }
            else
            {
                if (extractedXMP)
                {
                    bytes = xmpBytes;
                    return(bytes != null);
                }
            }

#if !GDIPLUS
            BitmapMetadata metaData = null;

            try
            {
                metaData = image.Metadata as BitmapMetadata;
            }
            catch (NotSupportedException)
            {
            }

            if (metaData == null)
            {
                extractedExif = true;
                extractedXMP  = true;

                return(false);
            }

            if (exif)
            {
                BitmapMetadata exifMetaData = MetaDataConverter.GetEXIFMetaData(metaData);

                if (exifMetaData == null)
                {
                    extractedExif = true;

                    return(false);
                }
                metaData = exifMetaData;
            }
            else
            {
                BitmapMetadata xmpMetaData = MetaDataConverter.GetXMPMetaData(metaData);

                if (xmpMetaData == null)
                {
                    extractedXMP = true;

                    return(false);
                }
                metaData = xmpMetaData;
            }
#endif

            if (exif)
            {
                using (MemoryStream ms = new MemoryStream())
                {
#if GDIPLUS
                    image.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
#else
                    JpegBitmapEncoder enc = new JpegBitmapEncoder();
                    enc.Frames.Add(BitmapFrame.Create(image, null, metaData, null));
                    enc.Save(ms);
#endif
                    exifBytes     = JpegReader.ExtractEXIF(ms.GetBuffer());
                    extractedExif = true;
                    bytes         = exifBytes;
                }
            }
            else
            {
                using (MemoryStream ms = new MemoryStream())
                {
#if GDIPLUS
                    image.Save(ms, System.Drawing.Imaging.ImageFormat.Tiff);
#else
                    TiffBitmapEncoder enc = new TiffBitmapEncoder();
                    enc.Frames.Add(BitmapFrame.Create(image, null, metaData, null));
                    enc.Save(ms);
#endif
                    xmpBytes     = TiffReader.ExtractXMP(ms);
                    extractedXMP = true;
                    bytes        = xmpBytes;
                }
            }

            return(bytes != null);
        }