winamp/Src/Plugins/Library/ml_devices/imageCache.cpp

#include "main.h"
#include "./imageCache.h"
#include <wincodec.h>
#include <vector>
#include <algorithm>


struct DeviceColoredImage
{
	size_t	 ref;
	DeviceImage *base;
	HBITMAP  bitmap;
	COLORREF color1;
	COLORREF color2;
	DeviceImageFilter filter;
	void *filterParam;
};

typedef std::vector<DeviceColoredImage*> DeviceColoredImageList;

struct DeviceImage
{
	size_t  ref;
	DeviceImageCache *cache;
	wchar_t *source;
	HBITMAP bitmap;
	HBITMAP exactBitmap;
	int width;
	int height;
	DeviceImageLoader loader;
	void *loaderParam;
	DeviceColoredImageList list;
};
typedef std::vector<DeviceImage*> DeviceImageList;

struct DeviceImageCache
{
	DeviceImageList list;
	IWICImagingFactory *wicFactory;
};

typedef struct DeviceImageSeachParam
{
	const wchar_t *path;
	int width;
	int height;
} DeviceImageSeachParam;

typedef struct DeviceColoredImageSeachParam
{
	COLORREF color1;
	COLORREF color2;
} DeviceColoredImageSeachParam;


DeviceImageCache *
DeviceImageCache_Create()
{
	DeviceImageCache *self;

	self = new DeviceImageCache();
	if (NULL == self)
		return NULL;

	self->wicFactory = NULL;

	return self;
}


void 
DeviceImageCache_Free(DeviceImageCache *self)
{
	if (NULL == self)
		return;

	size_t index = self->list.size();
	while(index--)
	{
		DeviceImage *image = self->list[index];
		image->cache = NULL;
	}

	if (NULL != self->wicFactory)
		self->wicFactory->Release();

	delete(self);
}


static DeviceImage *
DeviceImage_Create(DeviceImageCache *cache, const wchar_t *path, int width, int height, 
				   DeviceImageLoader loader, void *loaderParam)
{
	DeviceImage *self;

	if (NULL == loader)
		return NULL;

	self = new DeviceImage();
	if (NULL == self)
		return NULL;
	
	self->ref = 1;
	self->cache = cache;
	self->source = ResourceString_Duplicate(path);
	self->loader = loader;
	self->loaderParam = loaderParam;
	self->bitmap = NULL;
	self->exactBitmap = NULL;
	self->width = width;
	self->height = height;
	
	return self;
}

static void
DeviceImage_Free(DeviceImage *self)
{
	if (NULL == self)
		return;

	if (NULL != self->source)
		ResourceString_Free(self->source);

	if (NULL != self->bitmap)
		DeleteObject(self->bitmap);

	if (NULL != self->exactBitmap && 
		self->exactBitmap != self->bitmap)
	{
		DeleteObject(self->exactBitmap);
	}

	delete(self);
}

static int 
DeviceImageCache_SearchCb(const void *key, const void *element)
{
	DeviceImageSeachParam *search;
	DeviceImage *image;
	int result;

	search = (DeviceImageSeachParam*)key;
	image = (DeviceImage*)element;
	
	result = search->height - image->height;
	if (0 != result)
		return result;

	result = search->width - image->width;
	if (0 != result)
		return result;
	
	if (FALSE != IS_INTRESOURCE(search->path) ||
		FALSE != IS_INTRESOURCE(image->source))
	{
		return (int)(INT_PTR)(search->path - image->source);
	}

	return CompareString(CSTR_INVARIANT, 0, search->path, -1, image->source, -1) - 2;
}

static int
DeviceImageCache_SortCb(const void *element1, const void *element2)
{
	DeviceImage *image1;
	DeviceImage *image2;
	int result;

	image1 = (DeviceImage*)element1;
	image2 = (DeviceImage*)element2;

	result = image1->height - image2->height;
	if (0 != result)
		return result;

	result = image1->width - image2->width;
	if (0 != result)
		return result;

	if (FALSE != IS_INTRESOURCE(image1->source) ||
		FALSE != IS_INTRESOURCE(image2->source))
	{
		return (int)(INT_PTR)(image1->source - image2->source);
	}

	return CompareString(CSTR_INVARIANT, 0, image1->source, -1, image2->source, -1) - 2;
}
static int
DeviceImageCache_SortCb_V2(const void* element1, const void* element2)
{
	return DeviceImageCache_SortCb(element1, element2) < 0;
}


static HBITMAP
DeviceImage_DefaultImageLoader(const wchar_t *path, int width, int height, void *param)
{
	HBITMAP bitmap;
	unsigned int flags;
	
	flags = ISF_PREMULTIPLY;
	if (FALSE == IS_INTRESOURCE(path))
		flags |= ISF_LOADFROMFILE;

	bitmap = Image_Load(path, SRC_TYPE_PNG, flags, 0, 0);

	return bitmap;
}

DeviceImage *
DeviceImageCache_GetImage(DeviceImageCache *self, const wchar_t *path, int width, int height, DeviceImageLoader loader, void *user)
{
	DeviceImage *image, *image_ptr = 0;
	DeviceImageSeachParam searchParam;

	if (width < 1)
		width = 0;
	
	if (height < 1)
		height = 0;

	if (NULL == self)
		return NULL;

	if (NULL == path ||
		(FALSE == IS_INTRESOURCE(path) && L'\0' == *path))
	{
		return NULL;
	}

	searchParam.height = height;
	searchParam.width = width;
	searchParam.path = path;

	//image_ptr = (DeviceImage**)bsearch(&searchParam, &self->list[0], self->list.size(),
	//									sizeof(DeviceImage**),
	//									DeviceImageCache_SearchCb);
	auto it = std::find_if(self->list.begin(), self->list.end(),
		[&](DeviceImage* upT) -> bool
		{
			return DeviceImageCache_SearchCb(&searchParam, upT) == 0;
		}
	);
	if (it != self->list.end())
	{
		image_ptr = *it;
	}


	if (NULL != image_ptr)
	{
		image = image_ptr;
		DeviceImage_AddRef(image);
		return image;
	}
	
	if (NULL == loader)
		loader = DeviceImage_DefaultImageLoader;

	image = DeviceImage_Create(self, path, width, height, loader, user);
	if (NULL != image)
	{
		self->list.push_back(image);
		//qsort(&self->list[0], self->list.size(), sizeof(DeviceImage**), DeviceImageCache_SortCb);
		std::sort(self->list.begin(), self->list.end(), DeviceImageCache_SortCb_V2);
	}

	return image;
}

static BOOL
DeviceImageCache_RemoveImage(DeviceImageCache *self, DeviceImage *image)
{
	size_t index;

	if (NULL == self || NULL == image)
		return FALSE;

	index = self->list.size();
	while(index--)
	{
		if (self->list[index] == image)
		{
			self->list.erase(self->list.begin() + index);
			return TRUE;
		}
	}

	return FALSE;
}
size_t
DeviceImage_AddRef(DeviceImage *self)
{
	if (NULL == self)
		return 0;
	return InterlockedIncrement((LONG*)&self->ref);
}

size_t
DeviceImage_Release(DeviceImage *self)
{
	size_t r;
	if (NULL == self || 0 == self->ref)
		return 0;
	
	r = InterlockedDecrement((LONG*)&self->ref);
	if (0 == r)
	{
		if (NULL != self->cache)
			DeviceImageCache_RemoveImage(self->cache, self);
		DeviceImage_Free(self);
		return 0;
	}

	return r;
}

BOOL
DeviceImage_GetSize(DeviceImage *self, int *width, int *height)
{
	if (NULL == self)
		return FALSE;

	if (NULL != width)
		*width = self->width;
	
	if (NULL != height)
		*height = self->height;

	return TRUE;
}

static IWICImagingFactory*
DeviceImage_GetWicFactory(DeviceImageCache *cache)
{
	IWICImagingFactory *wicFactory;
	HRESULT hr;
	
	if (NULL != cache &&
		NULL != cache->wicFactory)
	{
		cache->wicFactory->AddRef();
		return cache->wicFactory;
	}
	
	hr = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, 
			IID_PPV_ARGS(&wicFactory));
	
	if (FAILED(hr))
		return NULL;

	if (NULL != cache)
	{
		wicFactory->AddRef();
		cache->wicFactory = wicFactory;
	}
	
	return wicFactory;
}


static HBITMAP
DeviceImage_HBitmapFromWicSource(IWICBitmapSource *wicSource, unsigned int targetWidth, 
								unsigned int targetHeight, DeviceImageFlags flags)
{
	HRESULT hr;
    HBITMAP bitmap;
	BITMAPINFO bitmapInfo;
	unsigned int width, height, bitmapWidth, bitmapHeight;
	void *pixelData = NULL;
    WICPixelFormatGUID pixelFormat;
	HDC windowDC;
	unsigned int strideSize, imageSize;

	if (NULL == wicSource)
		return NULL;

	hr = wicSource->GetPixelFormat(&pixelFormat);
	if (FAILED(hr) ||
		(GUID_WICPixelFormat32bppPBGRA != pixelFormat &&
		GUID_WICPixelFormat32bppBGR != pixelFormat &&
		GUID_WICPixelFormat32bppBGRA != pixelFormat &&
		GUID_WICPixelFormat32bppRGBA != pixelFormat &&
		GUID_WICPixelFormat32bppPRGBA != pixelFormat))
	{
		return NULL;
	}
    
    hr = wicSource->GetSize(&width, &height);
	if (FAILED(hr))
		return NULL;
    
	if (0 != (DeviceImage_ExactSize & flags))
	{
		bitmapWidth = (targetWidth > width) ? targetWidth : width;
		bitmapHeight = (targetHeight > height) ? targetHeight : height;
	}
	else
	{
		bitmapWidth = width;
		bitmapHeight = height;
	}
	
	ZeroMemory(&bitmapInfo, sizeof(bitmapInfo));
    bitmapInfo.bmiHeader.biSize  = sizeof(BITMAPINFOHEADER);
    bitmapInfo.bmiHeader.biWidth = bitmapWidth;
    bitmapInfo.bmiHeader.biHeight = -(LONG)bitmapHeight;
	bitmapInfo.bmiHeader.biPlanes = 1;
	bitmapInfo.bmiHeader.biBitCount = 32;
    bitmapInfo.bmiHeader.biCompression = BI_RGB;

	windowDC = GetDCEx(NULL, NULL, DCX_WINDOW | DCX_CACHE);
 
	bitmap = CreateDIBSection(windowDC, &bitmapInfo, DIB_RGB_COLORS, &pixelData, NULL, 0);
		
	if (NULL != windowDC)
		ReleaseDC(NULL, windowDC);

	if (NULL == bitmap)
		return NULL;

    hr = UIntMult(bitmapWidth, sizeof(DWORD), &strideSize);
    if (SUCCEEDED(hr))
	{
		if (0 != (DeviceImage_ExactSize & flags) &&
			(bitmapWidth > width || bitmapHeight > height))
		{
			if (SUCCEEDED(UIntMult(strideSize, bitmapHeight, &imageSize)))
				ZeroMemory(pixelData, imageSize);
		}

		hr = UIntMult(strideSize, height, &imageSize);
    	if (SUCCEEDED(hr))
		{
			unsigned int offset, delta;

			offset = 0;

			if (0 != (DeviceImage_AlignVCenter & flags))
			{
				delta = bitmapHeight - height;
				delta = delta/2 + delta%2;
			}
			else if (0 != (DeviceImage_AlignBottom & flags))
				delta = bitmapHeight - height;
			else
				delta = 0;

			if (0 != delta && SUCCEEDED(UIntMult(delta, strideSize, &delta)))
				offset += delta;
						
			if (0 != (DeviceImage_AlignHCenter & flags))
			{
				delta = bitmapWidth - width;
				delta = delta/2;
			}
			else if (0 != (DeviceImage_AlignRight & flags))
				delta = bitmapWidth - width;
			else 
				delta = 0;

			if (0 != delta && SUCCEEDED(UIntMult(delta, sizeof(DWORD), &delta)))
				offset += delta;
			
			hr = wicSource->CopyPixels(NULL, strideSize, imageSize, ((BYTE*)pixelData) + offset);
		}
    }
    
	if (FAILED(hr))
	{
		DeleteObject(bitmap);
		bitmap = NULL;
	}
    
	return bitmap;
}

static BOOL
DeviceImage_ScaleBitmap(HBITMAP sourceBitmap, int width, int height, DeviceImageCache *cache, 
						DeviceImageFlags flags, HBITMAP *scalledBitmap)
{
	HBITMAP resultBitmap;
	BITMAP sourceInfo;
	IWICImagingFactory *wicFactory;
	unsigned int requestedWidth, requestedHeight;
	double scale, scaleH;
	int t;

	if (NULL == sourceBitmap || NULL == scalledBitmap)
		return FALSE;

	if (sizeof(sourceInfo) != GetObject(sourceBitmap, sizeof(sourceInfo), &sourceInfo))
		return FALSE;
	
	if (sourceInfo.bmHeight < 0)
		sourceInfo.bmHeight = -sourceInfo.bmHeight;

	scale = (double)width / sourceInfo.bmWidth;
	scaleH = (double)height / sourceInfo.bmHeight;
				
	if (scale > scaleH)
		scale = scaleH;

	if (1.0 == scale)
	{
		*scalledBitmap = NULL;
		return TRUE;
	}

	requestedWidth = width;
	requestedHeight = height;

	t = (int)((sourceInfo.bmWidth * scale) + 0.5);
	if (t < width)
		width = t;

	t = (int)((sourceInfo.bmHeight * scale) + 0.5);
	if (t < height)
		height = t;
	
	
	resultBitmap = NULL;

	wicFactory = DeviceImage_GetWicFactory(cache);
	if (NULL != wicFactory)
	{
		HRESULT hr;
		IWICBitmap *wicBitmap;
		
		hr = wicFactory->CreateBitmapFromHBITMAP(sourceBitmap, NULL, 
							WICBitmapUsePremultipliedAlpha, &wicBitmap);
		if (SUCCEEDED(hr))
		{
			IWICBitmapScaler *wicScaler;	
			hr = wicFactory->CreateBitmapScaler(&wicScaler);
			if (SUCCEEDED(hr))
			{
				hr = wicScaler->Initialize(wicBitmap, width, height, WICBitmapInterpolationModeFant);
					if (SUCCEEDED(hr))
				{
					resultBitmap = DeviceImage_HBitmapFromWicSource(wicScaler, 
										requestedWidth, requestedHeight, flags);
				}
				wicScaler->Release();
				
			}
			wicBitmap->Release();
		}

		wicFactory->Release();
	}

	*scalledBitmap = resultBitmap;
	return (NULL != resultBitmap);
}

static HBITMAP
DeviceImage_GetExactBitmap(DeviceImage *self, DeviceImageFlags flags)
{
	if (NULL == self)
		return NULL;

	if (NULL == self->exactBitmap)
	{		
		if (NULL != self->bitmap)
		{
			BITMAP bi;
			if (sizeof(bi) == GetObject(self->bitmap, sizeof(bi), &bi) &&
				bi.bmWidth == self->width && bi.bmHeight == self->height)
			{
				self->exactBitmap = self->bitmap;
				return self->exactBitmap;
			}
		}

		if (NULL != self->loader)
		{
			HBITMAP bitmap;
			bitmap = self->loader(self->source, self->width, self->height, self->loaderParam);
			if (NULL != bitmap)
			{				
				if (FALSE != DeviceImage_ScaleBitmap(bitmap, self->width, self->height, 
											self->cache, flags, &self->exactBitmap))
				{
				
					if (NULL == self->exactBitmap)
					{
						self->exactBitmap = bitmap;
						bitmap = NULL;
					}
				}
				
				if (NULL != bitmap)
					DeleteObject(bitmap);
			}
		}
	}

	return self->exactBitmap;
}


HBITMAP
DeviceImage_GetBitmap(DeviceImage *self, DeviceImageFlags flags)
{
	if (NULL == self)
		return NULL;

	if (0 != (DeviceImage_ExactSize & flags))
		return DeviceImage_GetExactBitmap(self, flags);

	if (NULL == self->bitmap)
	{		
		if (NULL != self->loader)
		{
			HBITMAP bitmap;
			bitmap = self->loader(self->source, self->width, self->height, self->loaderParam);
			if (NULL != bitmap)
			{				
				if (FALSE == DeviceImage_ScaleBitmap(bitmap, self->width, self->height, 
											self->cache, flags, &self->bitmap))
				{
					self->bitmap = NULL;
				}

				if (NULL != self->bitmap)
					DeleteObject(bitmap);
				else
					self->bitmap = bitmap;
			}
		}
	}

	return self->bitmap;
}


static DeviceColoredImage *
DeveiceColoredImage_Create(DeviceImage *base, COLORREF color1, COLORREF color2, 
							DeviceImageFilter filter, void *user)
{
	DeviceColoredImage *coloredImage;

	if (NULL == base)
		return NULL;
	
	coloredImage = (DeviceColoredImage*)malloc(sizeof(DeviceColoredImage));
	if (NULL == coloredImage)
		return NULL;

	ZeroMemory(coloredImage, sizeof(DeviceColoredImage));

	coloredImage->ref = 1;
	coloredImage->base = base;
	coloredImage->color1 = color1;
	coloredImage->color2 = color2;
	coloredImage->filter = filter;
	coloredImage->filterParam = user;

	DeviceImage_AddRef(base);

	return coloredImage;
}

static void
DeviceColoredImage_Free(DeviceColoredImage *self)
{
	if (NULL == self)
		return;

	if (NULL != self->bitmap)
		DeleteObject(self->bitmap);
	
	free(self);
}

static int 
DeviceColoredImage_SearchCb(const void *key, const void *element)
{
	DeviceColoredImageSeachParam *search;
	DeviceColoredImage *image;
	int result;

	search = (DeviceColoredImageSeachParam*)key;
	image = (DeviceColoredImage*)element;
	
	result = search->color1 - image->color1;
	if (0 != result)
		return result;

	return search->color2- image->color2;
	
}

static int
DeviceColoredImage_SortCb(const void *element1, const void *element2)
{
	DeviceColoredImage *image1;
	DeviceColoredImage *image2;
	int result;

	image1 = (DeviceColoredImage*)element1;
	image2 = (DeviceColoredImage*)element2;

	result = image1->color1 - image2->color1;
	if (0 != result)
		return result;

	return image1->color2- image2->color2;
}

static int
DeviceColoredImage_SortCb_V2(const void* element1, const void* element2)
{
	return DeviceColoredImage_SortCb(element1, element2) < 0;
}

DeviceColoredImage *
DeviceImage_GetColoredImage(DeviceImage *self,  COLORREF color1, COLORREF color2, 
							DeviceImageFilter filter, void *user)
{
	size_t listSize;
	DeviceColoredImage *image;
	DeviceColoredImageSeachParam searchParam;

	searchParam.color1 = color1;
	searchParam.color2 = color2;
	
	listSize = self->list.size();
	if (listSize > 0)
	{
		DeviceColoredImage* image_ptr = NULL;
		//DeviceColoredImage **image_ptr = (DeviceColoredImage**)bsearch(&searchParam, &self->list[0], listSize,
		//									sizeof(DeviceColoredImage**),
		//									DeviceColoredImage_SearchCb);

		auto it = std::find_if(self->list.begin(), self->list.end(),
			[&](DeviceColoredImage* upT) -> bool
			{
				return DeviceColoredImage_SearchCb(&searchParam, upT) == 0;
			}
		);
		if (it != self->list.end())
		{
			image_ptr = *it;
		}

		if (NULL != image_ptr)
		{
			image = image_ptr;
			DeviceColoredImage_AddRef(image);
			return image;
		}
	}

	image = DeveiceColoredImage_Create(self, color1, color2, filter, user);
	if (NULL == image)
		return NULL;

	self->list.push_back(image);
	listSize++;

	if (listSize > 1)
	{
		//qsort(&self->list[0], self->list.size(), sizeof(DeviceColoredImage**),
		//	DeviceColoredImage_SortCb);
		std::sort(self->list.begin(), self->list.end(), DeviceColoredImage_SortCb_V2);
	}

	return image;
}

static void
DeviceImage_RemoveColored(DeviceImage *self, DeviceColoredImage *coloredImage)
{
	size_t index;

	if (NULL == self || NULL == coloredImage)
		return;

	index = self->list.size();
	while(index--)
	{
		if (coloredImage == self->list[index])
		{
			self->list.erase(self->list.begin() + index);
		}
	}
}

size_t
DeviceColoredImage_AddRef(DeviceColoredImage *self)
{
	if (NULL == self)
		return 0;
	return InterlockedIncrement((LONG*)&self->ref);
}

size_t
DeviceColoredImage_Release(DeviceColoredImage *self)
{
	size_t r;
	if (NULL == self || 0 == self->ref)
		return 0;
	
	r = InterlockedDecrement((LONG*)&self->ref);
	if (0 == r)
	{
		if (NULL != self->base)
		{
			DeviceImage_RemoveColored(self->base, self);
			DeviceImage_Release(self->base);
		}
		DeviceColoredImage_Free(self);
		return 0;
	}

	return r;
}

static BOOL
DeviceColoredImage_DefaultFilter(HBITMAP bitmap, COLORREF color1, COLORREF color2, void *user)
{
	DIBSECTION bitmapDib;
	BITMAP *bitmapInfo;
	MLIMAGEFILTERAPPLYEX filter;
	
	if (sizeof(bitmapDib) != GetObjectW(bitmap, sizeof(bitmapDib), &bitmapDib))
		return FALSE;

	bitmapInfo = &bitmapDib.dsBm;
		
	filter.cbSize = sizeof(filter);
	filter.pData = (BYTE*)bitmapInfo->bmBits;
	filter.cx = bitmapInfo->bmWidth;
	filter.cy = bitmapInfo->bmHeight;
	filter.bpp = bitmapInfo->bmBitsPixel;
	filter.imageTag = NULL;

	filter.filterUID = MLIF_GRAYSCALE_UID;
	MLImageFilter_ApplyEx(Plugin_GetLibraryWindow(), &filter);

	filter.rgbBk = color1;
	filter.rgbFg = color2;

	if (32 == bitmapInfo->bmBitsPixel)
	{
		filter.filterUID = MLIF_FILTER1_PRESERVE_ALPHA_UID;
		MLImageFilter_ApplyEx(Plugin_GetLibraryWindow(), &filter);
	}
	else
	{
		filter.filterUID = MLIF_FILTER1_UID;
		MLImageFilter_ApplyEx(Plugin_GetLibraryWindow(), &filter);
	}

	return TRUE;
}

HBITMAP
DeviceColoredImage_GetBitmap(DeviceColoredImage *self, DeviceImageFlags flags)
{
	if (NULL == self)
		return NULL;

	if (NULL == self->bitmap)
	{
		HBITMAP  bitmap;
		bitmap = DeviceImage_GetBitmap(self->base, flags);
		if (NULL != bitmap)
		{
			self->bitmap = Image_DuplicateDib(bitmap);
			if (NULL != self->bitmap)
			{
				DeviceImageFilter filter;
				if (NULL == self->filter)
					filter = DeviceColoredImage_DefaultFilter;
				else
					filter = self->filter;
			
				Image_Demultiply(self->bitmap, NULL);
				filter(self->bitmap, self->color1, self->color2, self->filterParam);
				Image_Premultiply(self->bitmap, NULL);
			}				
		}
	}

	return self->bitmap;
}

DeviceImage*
DeviceColoredImage_GetBaseImage(DeviceColoredImage *self)
{
	if (NULL == self || NULL == self->base)
		return NULL;

	DeviceImage_AddRef(self->base);
	return self->base;
}