Crash to Desktop

[joeb2000]

Describe the bug
Crash to desktop, no warning or other pop-up.

Exact Steps to Reproduce
I cannot reproduce it at will. It seems to happen randomly while scrolling through pages. It doesnt happen on same books, it doesnt happen at any specific interval.

Screenshots
If applicable, add screenshots to help explain your problem.

Version/Commit (check the about page, next to the version, for the string between brackets):

• Version: 0.9.182
• Commit: 13b2246

Additional context
I cannot find any log or anything the program itself leaves as to what exactly happened. The only thing I can find is in Windows Event Viewer. It looks like it is a .NET crash. Below is the event properties. I have checked the last 4 and they are all the exact same text. I also made sure I updated .NET, although comicrackCE looks like it still uses and older version from this log.

If you have a crash dump paste it between ```

Source: .NET Runtime
Application: ComicRack.exe
Framework Version: v4.0.30319
Description: The process was terminated due to an unhandled exception.
Exception Info: System.AccessViolationException
   at cYo.Common.Drawing.ImageProcessing+<>c__DisplayClass57_0.<ResizeFast>b__0(Int32)
   at System.Threading.Tasks.Parallel+<>c__DisplayClass17_0`1[[System.__Canon, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]].<ForWorker>b__1()
   at System.Threading.Tasks.Task.InnerInvokeWithArg(System.Threading.Tasks.Task)
   at System.Threading.Tasks.Task+<>c__DisplayClass176_0.<ExecuteSelfReplicating>b__0(System.Object)
   at System.Threading.Tasks.Task.Execute()
   at System.Threading.ExecutionContext.RunInternal(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean)
   at System.Threading.ExecutionContext.Run(System.Threading.ExecutionContext, System.Threading.ContextCallback, System.Object, Boolean)
   at System.Threading.Tasks.Task.ExecuteWithThreadLocal(System.Threading.Tasks.Task ByRef)
   at System.Threading.Tasks.Task.ExecuteEntry(Boolean)
   at System.Threading.ThreadPoolWorkQueue.Dispatch()

[maforget]

This has been an annoying issue since the beginning. It happens when the thumbnails are created when resizing to a smaller size.

Relevant code:

ComicRackCE/cYo.Common/Drawing/ImageProcessing.cs

Lines 899 to 1124 in 13b2246

	public unsafe static Bitmap ResizeFast(Bitmap source, int newWidth, int newHeight, PixelFormat format, ResizeFastInterpolation method)
	{
	Bitmap bitmap = source;
	//If format requested is anything other than 24 or 32 bit. Force format to be 32bit
	if (format != PixelFormat.Format32bppArgb && format != PixelFormat.Format24bppRgb)
	format = PixelFormat.Format32bppArgb;
	// get source image size
	int width = bitmap.Width;
	int height = bitmap.Height;
	//No need to resize, return a copy of the same image
	if (newWidth == width && newHeight == height)
	return bitmap.CreateCopy(format);
	//IF source image isn't 24bit or 32bit force create a copy with color
	if (bitmap.PixelFormat != PixelFormat.Format32bppArgb && bitmap.PixelFormat != PixelFormat.Format24bppRgb)
	bitmap = bitmap.CreateCopy(PixelFormat.Format32bppArgb);
	BitmapData srcData = null;
	BitmapData dstData = null;
	Bitmap dstImage = null;
	try
	{
	// Reference: https://github.com/andrewkirillov/AForge.NET/blob/master/Sources/Imaging/Filters/Base%20classes/BaseTransformationFilter.cs#L61
	// Also: https://github.com/andrewkirillov/AForge.NET/blob/master/Sources/Imaging/Filters/Base%20classes/BaseTransformationFilter.cs#L103
	// lock source bitmap data
	srcData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
	// create new image of required format
	dstImage = new Bitmap(newWidth, newHeight, format);
	// lock destination bitmap data
	dstData = dstImage.LockBits(new Rectangle(0, 0, newWidth, newHeight), ImageLockMode.ReadWrite, dstImage.PixelFormat);
	int srcStride = srcData.Stride;
	int srcPixelSize = srcStride / width;
	//int srcOffset = srcStride - srcPixelSize * width;
	int dstStride = dstData.Stride;
	int dstPixelSize = dstStride / newWidth;
	//int dstOffset = dstStride - srcPixelSize * newWidth;
	int minPixelSize = Math.Min(srcPixelSize, dstPixelSize);
	int dstExtra = dstPixelSize - minPixelSize;
	float xFactor = (float)width / (float)newWidth;
	float yFactor = (float)height / (float)newHeight;
	// do the job
	byte* orgsrc = (byte*)srcData.Scan0.ToPointer();
	byte* orgdst = (byte*)dstData.Scan0.ToPointer();
	//Image has 4 bytesPerPixel (32 bit), so Add Alpha Channel
	if (dstPixelSize == 4)
	InitializeAlpha32(orgdst, newWidth, newHeight, dstStride);
	switch (method)
	{
	case ResizeFastInterpolation.NearestNeighbor:
	// for each line
	Parallel.For(0, newHeight, (int y) =>
	{
	//Ref: https://github.com/andrewkirillov/AForge.NET/blob/master/Sources/Imaging/Filters/Transform/ResizeNearestNeighbor.cs#L81
	byte* dst = orgdst + dstStride * y;
	byte* src = orgsrc + srcStride * ((int)(y * yFactor));
	// for each pixel
	for (int x = 0; x < newWidth; x++)
	{
	byte* p = src + srcPixelSize * ((int)(x * xFactor));
	for (int i = 0; i < minPixelSize; i++, dst++, p++)
	{
	*dst = *p;
	}
	dst += dstExtra;
	}
	});
	break;
	case ResizeFastInterpolation.Bilinear:
	{
	// Ref: https://github.com/andrewkirillov/AForge.NET/blob/master/Sources/Imaging/Filters/Transform/ResizeBilinear.cs#L78
	// width and height decreased by 1
	int ymax = height - 1;
	int xmax = width - 1;
	// for each line
	Parallel.For(0, newHeight, (int y) =>
	{
	byte* dst = orgdst + y * dstStride;
	// Y coordinates
	float oy = (float)y * yFactor;
	int oy1 = (int)oy;
	int oy2 = (oy1 == ymax) ? oy1 : (oy1 + 1);
	float dy1 = oy - (float)oy1;
	float dy2 = 1f - dy1;
	// get temp pointers
	byte* tp1 = orgsrc + oy1 * srcStride;
	byte* tp2 = orgsrc + oy2 * srcStride;
	// for each pixel
	for (int x = 0; x < newWidth; x++)
	{
	// X coordinates
	float ox = (float)x * xFactor;
	int ox1 = (int)ox;
	int ox2 = (ox1 == xmax) ? ox1 : (ox1 + 1);
	float dx1 = ox - (float)ox1;
	float dx2 = 1f - dx1;
	// get four points
	byte* p1 = tp1 + ox1 * srcPixelSize;
	byte* p2 = tp1 + ox2 * srcPixelSize;
	byte* p3 = tp2 + ox1 * srcPixelSize;
	byte* p4 = tp2 + ox2 * srcPixelSize;
	// interpolate using 4 points
	for (int i = 0; i < minPixelSize; i++, dst++, p1++, p2++, p3++, p4++)
	{
	byte b = (byte)((double)dx2 * (double)*p1 + (double)dx1 * (double)*p2);
	byte b2 = (byte)((double)dx2 * (double)*p3 + (double)dx1 * (double)*p4);
	*dst = (byte)((double)dy2 * (double)b + (double)dy1 * (double)b2);
	}
	dst += dstExtra;
	}
	});
	break;
	}
	case ResizeFastInterpolation.Bicubic:
	{
	// Ref: https://github.com/andrewkirillov/AForge.NET/blob/master/Sources/Imaging/Filters/Transform/ResizeBicubic.cs#L79
	// width and height decreased by 1
	int ymax = height - 1;
	int xmax = width - 1;
	Parallel.For(0, newHeight, (int y) =>
	{
	byte* dst = orgdst + y * dstStride;
	// Y coordinates
	float oy = (float)y * yFactor - 0.5f;
	int oy1 = (int)oy;
	float dy = oy - (float)oy1;
	float[] array = new float[4];
	for (int x = 0; x < newWidth; x++)
	{
	// X coordinates
	float ox = (float)x * xFactor - 0.5f;
	int ox1 = (int)ox;
	float dx = ox - (float)ox1;
	// initial pixel value
	for (int l = 0; l < minPixelSize; l++)
	{
	array[l] = 0f;
	}
	for (int n = -1; n < 3; n++)
	{
	// get Y coefficient
	float k1 = BiCubicKernel(dy - (float)n);
	int oy2 = oy1 + n;
	if (oy2 < 0)
	oy2 = 0;
	if (oy2 > ymax)
	oy2 = ymax;
	for (int m = -1; m < 3; m++)
	{
	// get X coefficient
	float k2 = k1 * BiCubicKernel((float)m - dx);
	int ox2 = ox1 + m;
	if (ox2 < 0)
	ox2 = 0;
	if (ox2 > xmax)
	ox2 = xmax;
	// temporary pointer
	byte* p = orgsrc + oy2 * srcStride + ox2 * srcPixelSize;
	for (int i = 0; i < minPixelSize; i++)
	{
	array[i] += k2 * (float)(int)p[i];
	}
	}
	}
	for (int i = 0; i < minPixelSize; i++)
	{
	byte* intPtr = dst + i;
	*intPtr = (byte)(*intPtr + (byte)array[i]);
	}
	dst += dstPixelSize;
	}
	});
	break;
	}
	}
	return dstImage;
	}
	catch (AccessViolationException)
	{
	return null;
	}
	finally
	{
	if (dstData != null)
	{
	// unlock destination image
	dstImage.UnlockBits(dstData);
	}
	if (srcData != null)
	{
	// unlock source image
	bitmap.UnlockBits(srcData);
	}
	if (bitmap != source)
	{
	bitmap.Dispose();
	}
	}
	}

It hard CTD because it is a memory violation trying to access out of bounds memory. It isn'T something that can be handled directly using a catch statement. I even decorated the method with a special Attribute so that it would catch it. It does help a little but once you have the error it never ends, so it just CTD anyway.

I believed it was due to the decompilation process, because I do not remember having it happened in the Original ComicRack. Some of the code had a lot of casting. I also found the initial code (Aforge.NET) that this seemed to be based on.

So I cleaned up the code based on that and it didn't help. This is the reason why I changed the default thumbnail resizing algorithm to FastAndUgly instead of FastBilinear like it used to be. So my first question is do you have the ThumbnailResampling changed in ComicRack.ini? Any of the 3 Fast Variant all use that same code.

I even reverted some of my changes I had made so that it matches the original decompiled code, but it still happens at times. I also though that running from a debug environnement might be related since their may be memory profiling going on in the background interfering.

I also tested using another package to resize image (see #83), but performance test using the current unsafe method were way better, so I never merged the changes.

So I went and decided to ask AI for help. It found out some issues that could be related that were in the referenced code and a potential critical issue regarding Bicubic (which I haven't used really). It's small changes but might explain why some files are ok when some aren't.

But since this isn't a consistent behavior it's hard to test. But one way I found that is pretty much always crashes is opening the Quick Introduction and switching to the pages view. It's not 100% but pretty consistent (also probably because thumbnails are cached so if they already exists it doesn't need to resize).

So I opened my current library with the latest version, opened the quick introduction and had a CTD. The key give away is when you start seeing Red X pages before it does. Then opened the same library using the new updated code and it didn't crash. Then went to open it again the latest version and CTD.

So we might have a fix. So I posted a PR with the potential fix. There is a download link posted by the Github bot that you can test and see if you have a different outcome.

#237

---

Relevant links

https://github.com/andrewkirillov/AForge.NET/blob/master/Sources/Imaging/Filters/Transform/ResizeNearestNeighbor.cs#L81
https://github.com/andrewkirillov/AForge.NET/blob/master/Sources/Imaging/Filters/Transform/ResizeBilinear.cs#L78
https://github.com/andrewkirillov/AForge.NET/blob/master/Sources/Imaging/Filters/Transform/ResizeBicubic.cs#L79

[joeb2000]

I have not changed the ThumbnailResampling, it is still set to FastAndUgly.

I will grab the new PR and test for a couple of days to see if it still crashes or if it is at least less crashing. Currently it was crashing daily (sometimes multiple times).

[maforget]

Not sure if the fix helped in anyway on your side (seeing you are using FastAndUgly), but personally I haven't had crashes yet, although they were very rare to begin with. I've merged the changes anyway because it will only help with some situations.

But will keep this issue open for now just in case there are more reports of this.