/// <summary>
/// Adds padding to a bitmap, optionally cropping it at the same time.
/// </summary>
/// <param name="s"></param>
/// <param name="left"></param>
/// <param name="top"></param>
/// <param name="right"></param>
/// <param name="bottom"></param>
/// <param name="bgcolor"></param>
/// <param name="crop"></param>
public WicBitmapPadder(IWICBitmapSource s, int left, int top, int right, int bottom, byte[] bgcolor, WICRect crop)
{
this.s = s;
this.left = left;
this.right = right;
this.bottom = bottom;
this.top = top;
this.bgcolor = bgcolor;
this.crop = crop;
Guid pf;
s.GetPixelFormat(out pf);
if (bgcolor.Length != ConversionUtils.BytesPerPixel(pf))
{
throw new ArgumentException("bgcolor length must match the format bytes per pixel");
}
}
public static byte[] ConvertColor(Color color, Guid pixelFormat)
{
if (pixelFormat == Consts.GUID_WICPixelFormat24bppBGR)
{
return new byte[] { color.B, color.G, color.R }
}
;
if (pixelFormat == Consts.GUID_WICPixelFormat24bppRGB)
{
return new byte[] { color.R, color.G, color.B }
}
;
if (pixelFormat == Consts.GUID_WICPixelFormat32bppBGR || pixelFormat == Consts.GUID_WICPixelFormat32bppBGRA ||
pixelFormat == Consts.GUID_WICPixelFormat32bppPBGRA)
{
return new byte[] { color.B, color.G, color.R, color.A }
}
;
if (pixelFormat == Consts.GUID_WICPixelFormat32bppPRGBA || pixelFormat == Consts.GUID_WICPixelFormat32bppRGBA)
{
return new byte[] { color.R, color.G, color.B, color.A }
}
;
if (pixelFormat == Consts.GUID_WICPixelFormat8bppGray)
{
return new byte[] { (byte)Math.Min(0, Math.Max(255, (float)color.B * 0.081f + (float)color.G * 0.419f + (float)color.R * 0.5f)) }
}
;
byte[] data = new byte[ConversionUtils.BytesPerPixel(pixelFormat)];
return(data);
}
}
}
public void CopyPixels(WICRect prc, uint destStride, uint destBufferSize, [Out]
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] destBuffer)
{
//Get normal size of source rect
uint sw, sh;
s.GetSize(out sw, out sh);
//Get normal (uncropped size) of this bitmap. Includes source cropping
uint fullWidth, fullHeight;
this.GetSize(out fullWidth, out fullHeight);
//Copy or generate source crop rectangle.
WICRect crop = this.crop == null ? new WICRect {
X = 0, Y = 0, Width = (int)sw, Height = (int)sh
}: new WICRect {
X = this.crop.X, Y = this.crop.Y, Width = this.crop.Width, Height = this.crop.Height
};
//Copy padding values so we can modify them based on the dest crop area.
int left = this.left;
int top = this.top;
int right = this.right;
int bottom = this.bottom;
int w = prc != null ? prc.Width : (int)fullWidth;
int h = prc != null ? prc.Height : (int)fullHeight;
//Adjust padding based on what they're asking to crop off
if (prc != null)
{
left -= prc.X;
top -= prc.Y;
right -= (int)(fullWidth - prc.X - prc.Width);
bottom -= (int)(fullHeight - prc.Y - prc.Height);
}
//Now, adjust negative padding to crop from the source bitmap. We should end up with only positive padding.
if (left < 0)
{
crop.X += left * -1; crop.Width += left; left = 0;
}
if (top < 0)
{
crop.Y += top * -1; crop.Height += top; top = 0;
}
if (right < 0)
{
crop.Width += right; right = 0;
}
if (bottom < 0)
{
crop.Height += bottom; bottom = 0;
}
//Now, if we don't have to add any padding (say the caller ended up cropping it all off), just pass the request on.
if (left == 0 && top == 0 && right == 0 && bottom == 0)
{
s.CopyPixels(crop, destStride, destBufferSize, destBuffer);
return;
}
//Ah, looks like we still have to do padding.
//Get pixel format
Guid format;
s.GetPixelFormat(out format);
//Calculate buffer and stride for source data
uint bpp = (uint)ConversionUtils.BytesPerPixel(format); //Round up to nearest byte.
uint srcStride = (((bpp * (uint)Math.Max(0, crop.Width)) + 4 - 1) / 4) * 4; //Round up to nearest 4-byte alignment
uint sbufferSize = srcStride * (uint)Math.Max(0, crop.Height);
//Allocate for source data
byte[] sbuffer = new byte[sbufferSize];
//Decode and store the source data
if (sbufferSize > 0)
{
s.CopyPixels(crop, srcStride, sbufferSize, sbuffer);
}
//Ok, now it's time to start work.
//Manually build a padding stride for left, top/bottom, and right, then use Array.Copy to do it more efficiently.
//Favor doing complete row - don't let left/right overlap with top/bottom.
if (left > 0 && h > (top + bottom))
{
//Cache manually built array for speed
if (cachedLeftPadding == null)
{
cachedLeftPadding = new byte[left * bpp];
for (int i = 0; i < left; i++)
{
Array.Copy(bgcolor, 0, cachedLeftPadding, i * bpp, bpp);
}
}
//Then copy it down
for (int j = 0; j < h - top - bottom; j++)
{
Array.Copy(cachedLeftPadding, 0, destBuffer, (destStride * (j + top)), left * bpp);
}
}
if (right > 0 && h > (top + bottom))
{
//Cache manually built array for speed
if (cachedRightPadding == null)
{
cachedRightPadding = new byte[right * bpp];
for (int i = 0; i < right; i++)
{
Array.Copy(bgcolor, 0, cachedRightPadding, i * bpp, bpp);
}
}
//Then copy it down
for (int j = 0; j < h - top - bottom; j++)
{
Array.Copy(cachedRightPadding, 0, destBuffer, (destStride * (j + top)) + (left + crop.Width) * bpp, right * bpp);
}
}
if (top > 0 || bottom > 0)
{
//Cache manually built array for speed
if (cachedRowPadding == null)
{
cachedRowPadding = new byte[(crop.Width + left + right) * bpp];
for (int i = 0; i < crop.Width + left + right; i++)
{
Array.Copy(bgcolor, 0, cachedRowPadding, i * bpp, bpp);
}
}
//Copy it down for both top and bottom
if (top > 0)
{
for (int j = 0; j < Math.Min(h, top); j++)
{
Array.Copy(cachedRowPadding, 0, destBuffer, (destStride * j), (crop.Width + left + right) * bpp);
}
}
if (bottom > 0)
{
for (int j = 0; j < Math.Min(h, bottom); j++) //If the manual row was at the bottom, don't copy it again.
{
Array.Copy(cachedRowPadding, 0, destBuffer, (destStride * (j + top + Math.Max(0, crop.Height))), (crop.Width + left + right) * bpp);
}
}
}
//Now, copy the image data. If we didn't use left or right padding we can copy the whole thing at once.
if (sbufferSize > 0)
{
if (srcStride == destStride)
{
Array.Copy(sbuffer, 0, destBuffer, top * destStride, sbuffer.Length);
}
else
{
//Otherwise, one row at a time
for (int j = 0; j < crop.Height; j++)
{
Array.Copy(sbuffer, j * srcStride, destBuffer, (left * bpp) + (top + j) * destStride, crop.Width * bpp);
}
}
}
//We're done!
}