• Hardware

  • Intel confirmed no dithering on Intel arc a770

Ivan_P

Also, could you share your method of checking output bit depth? (to test that changing registers truly made things)

Switching between 6 and 8+ bits is determined by this video: https://www.youtube.com/watch?v=suAR1PYFNYA. Once the player opens, you can pause it immediately at the 0-second mark. At the very beginning, there will be very contrasting waves on the gradient on 6 bits, while on 8+ bits, the gradient will be smooth without waves.

can you tell me what files and what lines in those files you changed?

Sorry, I don't know if you have any knowledge of programming. I'll describe it as it is. If it's difficult to understand, I can later upload everything to GitHub in a ready-to-build format.

This line https://github.com/skawamoto0/ditherig/blob/2fb5b3a3b8edc405c3427757e1213cc9fcafbc9f/ditherig/ditherig.cpp#L625C1-L626C1 is responsible for forming a new value that will be written to the register. We need to clear bits 4-7 and then set the 6th bit. Bits are counted from right to left starting at zero. This way, we will disable dithering if it was enabled by default (by clearing the 4th bit of the register) and set the color depth to 6 bits on output (bits 5-7 of the register are responsible for this; 010 - 6-bit output; 000 - 8-bit output). It should look something like this:

if(ReadPhysicalMemory(Address + RegisterAddress, &Old, RegisterSize))
{
	New = Old;
	New = (New & ~RegisterMask) | (RegisterData & RegisterMask);

       // { new code starts here

	New &= 0xFFFFFF0F;
        // enable 6-bit output mode; 
        // comment out the line bellow to switch to 8-bit output mode 
	New |= (1 << 6);

       // } new code ends here

	if (New == Old)
		bResult = TRUE;
	else
	{
		if(WritePhysicalMemory(Address + RegisterAddress, &New, RegisterSize))
			bResult = TRUE;

	}
}

I built it in Visual Studio 2022 (a conversion to the new project format is needed; MFC will also be needed here).

This line needs to be removed before building: https://github.com/skawamoto0/ditherig/blob/2fb5b3a3b8edc405c3427757e1213cc9fcafbc9f/ditherig/stdafx.h#L21. Additionally, you need to copy all the DLLs from the project folders (InpOut32, WinRing0) into the folder where the compiled binary will be.

I would like to experiment with my 8 to 11-generation Intel laptops.

I only have a 12th generation CPU for a laptop, so I can't test it on earlier versions. However, according to the comment in the i915 module code, this will only work starting from the 12th generation (ADLP+).

      amd cards will generally do 6 bit with displayport fyi.

      simplex 8 bit = 1 (truncate data)

      In this case, the code will be like this

      New &= 0xFFFFFE0F;
// Comment out the line below to switch to 8-bit output mode.
// Uncomment to switch to 6-bit output mode.
New |= (1 << 6);
// set Pixel Rounding to Truncate
New |= (1 << 8);

        WhisperingWind Address + RegisterAddress, &New, RegisterSize

        WhisperingWind, maybe you can help with my stuck?

        I am tryied to hardcode this part to Address + 0x00070030, &Old, 0x4 it works, but when I set 0x3C000000 + 0x00070030, &Old, 0x4 it didnt.

        Address = ((DWORD_PTR)BAR1 | ((DWORD_PTR)BAR2 << 32)) & ~((DWORD_PTR)0x10 - 1)keeping BAR1:0x3C000004 и BAR2:0x00000060

        What part I am missing, why I cant hardcode address…?

            So I wanted to come in here and say that I specifically bought an Intel Arc A750 Limited Edition in the hopes that it wouldn’t dither on Windows 11. Unfortunately? Even with Ditherig running, I’m still feeling that hazy fatigue feeling after 30 minutes of use as if some area behind my eyes is being pulverized. Other Windows 11 gpus/laptops or screens give me intense eye strain as if I can’t focus on the text at all but not this one. It’s a different feeling but it’s just as unusable. I’ve tried adjusting so many things and have had no luck with Windows 11 :/

              ,,,,,,,,,,

              simplex

              The Address has been calculated incorrectly. If BAR1=0x3c000004 and BAR2=0x00000060, then the value of Address should be 0x000000603c000000.

                whystrainwhy

                Make sure your monitor is safe. Try installing Linux and check for dithering as moonpie suggests. Evaluate how comfortable it is for you to work with your monitor in this case.

                  2 months later

                  We already know how to determine the presence of spatial dithering by reading the state of the Intel iGPU/GPU controller register. But I became curious whether it is possible to visually see the presence of spatial dithering on Intel graphics cards. And at the same time, check if it is possible to enable temporal dithering. There will be nothing new in this post, only a visual confirmation of the facts we have known for a long time.

                  The test was conducted on Windows 10 22H2 using an Intel ASRock ARC A770. To enable or disable dithering, the application ditherig was used.

                  Screenshots were taken using a Blackmagic UltraStudio Recorder 3G. Since it doesn't always work correctly with the HDMI port on the ARC GPU, I connected it via DP.

                  Link to the archive with screenshots and resulting comparison files.

                  The comparison was performed using this python script.

                  The archive contains pairs of screenshots with dithering (spatial dithering) enabled and completely disabled, as well as the result of their pixel-by-pixel comparison. There is one unpaired screenshot, without_ditherig_app.tga, which was taken after unloading the ditherig application and restarting the PC to ensure that the GPU register states were reset to their default values.

                  In the resulting comparison images, the first image of the two being compared is used as a blurred background. Red dots indicate pixels that differ. As you can see, spatial dithering most often manifests as something resembling a "checkerboard" pattern.

                  Note that spatial dithering is predictably absent on white (255, 255, 255). However, on (254, 254, 254), it is present and appears as an alternation of pixels (255, 255, 255) and (254, 254, 254). This can be seen in spatial_dithering.tga (the photo with the girls). You need to check the "white" using any colorimeter application.

                  As I mentioned above, I also took a screenshot when the ditherig application was not being used. It matched pixel-for-pixel with the screenshot taken after enabling the dithering disable option in the ditherig application. It shows that, by default, dithering is completely absent.

                  What surprised me: the option to enable temporal dithering also works. This means temporal dithering can be enabled on some Intel iGPUs/GPUs. I suppose this will definitely include all iGPU/GPU based on the Xe architecture (ARC A, Intel iGPUs from the 11th to 14th CPU generations). I can't say about others. If needed, I can compress and upload video files (the original files are very large), which demonstrate the presence of temporal dithering when the corresponding option is enabled.

                    In the future, I plan to compare the ASRock ARC A770 with Intel UHD 48EUs (Tecno MEGA Mini M1 mini-PC), as I find the Intel UHD 48EUs slightly more comfortable for my eyes. I'm curious to understand why. My current hypothesis is that it could be due to differences in sharpness/softness of the image or differences in default gamma/contrast values.

                      WhisperingWind that would be interesting to hear. I am wondering if intel NIC's could be causing strain? Unsure what that mini pc uses but between me and another person "bad" motherboards had intel nic/ethernet

                          jordan

                          I haven't personally used the Intel NIC, so I can't provide any specific feedback on it.

                          My mini-PC is equipped with an Intel i225-V 2.5 Gbps Ethernet and Intel Wi-Fi 6 AX201.

                            dev