Exemplo n.º 1
0
        /// <summary>
        /// Internal method for creating Image from Bitmap.
        /// </summary>
        /// <param name="bitmap">
        /// A <see cref="Drawing.Bitmap"/> to be converted into an <see cref="Image"/> instance.
        /// </param>
        /// <param name="criteria">
        /// A <see cref="MediaCodecCriteria"/> that specify image conversion criteria.
        /// </param>
        /// <returns>
        /// It returns a <see cref="Image"/> instance that's equivalent to <paramref name="bitmap"/>.
        /// </returns>
        /// <exception cref="ArgumentNullException">
        /// Exception thrown if <paramref name="bitmap"/> or <see cref="criteria"/> is null.
        /// </exception>
        internal static Image LoadFromBitmap(Bitmap bitmap, ImageCodecCriteria criteria)
        {
            if (bitmap == null)
            {
                throw new ArgumentNullException("bitmap");
            }
            if (criteria == null)
            {
                throw new ArgumentNullException("criteria");
            }

            PixelLayout pType, pConvType;

            // Allocate image raster
            ConvertPixelFormat(bitmap, out pType);

            // Check for hardware/software support
            if (pType.IsSupportedInternalFormat() == false)
            {
                if (criteria.IsSet(ImageCodecCriteria.SoftwareSupport) && ((bool)criteria[ImageCodecCriteria.SoftwareSupport]))
                {
                    // Pixel type not directly supported by hardware... try to guess suitable software conversion
                    throw new NotImplementedException(String.Format("pixel type {0} is not supported by hardware neither software", pType));
                }
                else
                {
                    throw new InvalidOperationException(String.Format("pixel type {0} is not supported by hardware", pType));
                }
            }
            else
            {
                pConvType = pType;
            }

            Image image = new Image(pType, (uint)bitmap.Width, (uint)bitmap.Height);

            switch (bitmap.PixelFormat)
            {
            case System.Drawing.Imaging.PixelFormat.Format1bppIndexed:
            case System.Drawing.Imaging.PixelFormat.Format4bppIndexed:
            case System.Drawing.Imaging.PixelFormat.Format8bppIndexed:
                if (Khronos.Platform.RunningMono)
                {
                    // Bug 676362 - Bitmap Clone does not format return image to requested PixelFormat
                    // https://bugzilla.novell.com/show_bug.cgi?id=676362
                    //
                    // ATM no mono version has resolved the bug; current workaround is performing image
                    // sampling pixel by pixel, using internal conversion routines, even if it is very slow

                    LoadBitmapByPixel(bitmap, image);
                }
                else
                {
                    LoadBitmapByClone(bitmap, image);
                }
                break;

            default:
                LoadBitmapByLockBits(bitmap, image);
                break;
            }

            return(image);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Load media from stream.
        /// </summary>
        /// <param name="stream">
        /// A <see cref="Stream"/> where the media data is stored.
        /// </param>
        /// <param name="criteria">
        /// A <see cref="MediaCodecCriteria"/> that specify parameters for loading an media stream.
        /// </param>
        /// <returns>
        /// An <see cref="Image"/> holding the media data.
        /// </returns>
        /// <exception cref="ArgumentNullException">
        /// Exception thrown if <paramref name="stream"/> or <paramref name="criteria"/> is null.
        /// </exception>
        public Image Load(Stream stream, ImageCodecCriteria criteria)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }
            if (criteria == null)
            {
                throw new ArgumentNullException("criteria");
            }

            using (System.Drawing.Bitmap iBitmap = new System.Drawing.Bitmap(stream)) {
                Image       image;
                PixelLayout pType, pConvType;

                // Allocate image raster
                ConvertPixelFormat(iBitmap, out pType);

                // Check for hardware/software support
                if (pType.IsSupportedInternalFormat() == false)
                {
                    if (criteria.IsSet(ImageCodecCriteria.SoftwareSupport) && (bool)criteria[ImageCodecCriteria.SoftwareSupport])
                    {
                        // Pixel type not directly supported by hardware... try to guess suitable software conversion
                        pConvType = Pixel.GuessBestSupportedConvertion(pType);
                        if (pConvType == PixelLayout.None)
                        {
                            throw new InvalidOperationException("pixel type " + pType.ToString() + " is not supported by hardware neither software");
                        }
                    }
                    else
                    {
                        throw new InvalidOperationException("pixel type " + pType.ToString() + " is not supported by hardware");
                    }
                }
                else
                {
                    pConvType = pType;
                }

                image = new Image();
                image.Create(pType, (uint)iBitmap.Width, (uint)iBitmap.Height);

                switch (iBitmap.PixelFormat)
                {
                case System.Drawing.Imaging.PixelFormat.Format1bppIndexed:
                case System.Drawing.Imaging.PixelFormat.Format4bppIndexed:
                case System.Drawing.Imaging.PixelFormat.Format8bppIndexed:
                    if (Platform.RunningMono)
                    {
                        // Bug 676362 - Bitmap Clone does not format return image to requested PixelFormat
                        // https://bugzilla.novell.com/show_bug.cgi?id=676362
                        //
                        // ATM no mono version has resolved the bug; current workaround is performing image
                        // sampling pixel by pixel, using internal conversion routines, even if it is very slow

                        LoadBitmapByPixel(iBitmap, image);
                    }
                    else
                    {
                        LoadBitmapByClone(iBitmap, image);
                    }
                    break;

                default:
                    LoadBitmapByLockBits(iBitmap, image);
                    break;
                }

                // ConvertItemType image to supported format, if necessary
                if ((pConvType != PixelLayout.None) && (pConvType != pType))
                {
                    image = image.Convert(pConvType);
                }

                return(image);
            }
        }