Tweaked Video Modes

Intro

Your video card may be holding out on you! Tweaked video modes are the modifying of Video Controller registers to attain non-standard video modes. What i mean by “non standard” are those that aren’t available directly by accessing the Video Bios. Even the VESA VBE doesn’t even support these modes! The wonderful thing about TVM (Tweaked Video Modes) are that they are VERY predictable, offer extended capabilities, can be faster, and are available on any video card bought within the last decade!

Each video mode requires a precise set of steps to make it work. You will also find that the means of getting to different video modes will very greatly. I will try to order these so that we start off with the easier ones 1st, and then graduate to higher levels of difficulty. One nice fact is that after we get these routines done, we can just call our function and bingo we will be in that video mode. That way we can forget *how* we got into that video mode and focus more on actually using it! Each section will cover one case that is located inside a switch() function inside our main modex video changing routine. Here’s what i mean:

C [Show Plain Code]:
  1. void Video::ModeX(short Width, short Height)
  2. {
  3.     if(Width == 320)
  4.     {
  5.         switch(Height)
  6.         {
  7.          case …:
  8.         }
  9.         Screen_Width=320;
  10.     }
  11.    
  12.     Move2Vid = &Video::MoveMemTweaked;
  13.     XCenter=Screen_Width>>1;
  14.     YCenter=Screen_Height>>1;
  15.  }

This function is going be called whenever tweaked video modes are passed to the main VideoMode(int) function. This way we can use one function for ALL video modes and just be concerned with the supporting functions to extend our functionality. This is also nice because it is easy to debug should something go wrong, and also a lot easier to read and understand. We are also going to be using 2 functions from 2 other tutorials. Don’t worry, they are really small and pretty darn easy to read, understanding, now that’s something different :) They are the StandardVideoMode() and the Unchain() functions.

Modes Covered

320×100
320×120
320×200
320×240
320×400
320×480


320×100 Unchained

C [Show Plain Code]:
  1. case 100:
  2. {
  3.     VideoMode(0×13);      //320×100 unchained
  4.     Unchain();
  5.     asm(" movw $0x3d4,%%dx
  6.           movw $0×4309,%%ax
  7.           out %%ax,%%dx"
  8.           :
  9.           :
  10.           :"%ax","%dx");
  11.     Screen_Height=100;
  12.     Sreen_Size = 32000;
  13.     break;
  14. }

or if you prefer straight C

C [Show Plain Code]:
  1. case 100:
  2. {
  3.     VideoMode(0×13);
  4.     Unchain();
  5.     outp(0x3d4,0×4309);
  6.     Screen_Height=100;
  7.     Screen_Size = 32000;
  8.     break;
  9. }

Here we are going into normal 320x200x256 mode, changing the video ram organization to unchained and then telling it that we want to display only 100 vertical lines instead of 200. We can easily do this by communicating with register 9 of the CRT. Bits 0-4 stand for the number of times to display the scanline minus 1. We can double our vertical resolution by doing an outp to port 0x3d4 with 0×4009. This is cool because when we go to tweaked modes like 320×240 we can use this technique to get 120 and 480 vertical resolutions. As you will find out this is exactly what we do!

320×120 Unchained

C [Show Plain Code]:
  1. case 120:
  2. {
  3.     VideoMode(0×13);     
  4.     Unchain();
  5.     asm("movw $0x3c2,%%dx
  6.          movb $0xe3,%%ax
  7.          out %%ax,%%dx
  8.                
  9.          movw $0x3d4,%%dx
  10.          movw $0x2c11,%%ax
  11.          out %%ax,%%dx
  12.                   
  13.          movw $0x0d06,%%ax
  14.          out %%ax,%%dx"
  15.                                   
  16.          movw $0x3e07,%%ax
  17.          out %%ax,%%dx
  18.                                         
  19.          movw $0xea10,%%ax
  20.          out %%ax,%%dx"
  21.                                 
  22.          movw $0xac11,%%ax
  23.          out %%ax,%%dx"
  24.                                 
  25.          movw $0xdf12,%%ax
  26.          out %%ax,%%dx"
  27.                                 
  28.          movw $0xe715,%%ax
  29.          out %%ax,%%dx"
  30.                   
  31.          movw $0×0616,%%ax
  32.          out %%ax,%%dx"
  33.                   
  34.          movw $0×4309,%%ax
  35.          out %%ax,%%dx"
  36.        :
  37.        :
  38.        :"%ax","%dx");break;
  39.        Screen_Height = 120;
  40.        Screen_Size = 38400;
  41.        break;
  42. }

or normal C++

C [Show Plain Code]:
  1. case 120:
  2. {
  3.     VideoMode(0×13);     
  4.     Unchain();
  5.     outpb(0x3c2,0xe3);
  6.     outpw(0x3d4,0x2c11);
  7.     outpw(0x3d4,0x0d06);
  8.     outpw(0x3d4,0x3e07);
  9.     outpw(0x3d4,0xea10);
  10.     outpw(0x3d4,0xac11);
  11.     outpw(0x3d4,0xdf12);
  12.     outpw(0x3d4,0xe715);
  13.     outpw(0x3d4,0×0616);
  14.     outpw(0x3d4,0×4309);
  15.     Screen_Height=120;
  16.     Screen_Size = 38400;
  17.     break;
  18. }

As I mentioned previously we are going into normal 320x200x256 mode, unchaining memory, and then changing the resolution to 320×240. Then we use our little technique that we learned above to go to 320×120!


320×200 Unchained

C [Show Plain Code]:
  1. case 200:
  2. {
  3.     VideoMode(0×13);     
  4.     Unchain();
  5.     Screen_Height=200;
  6.     Screen_Size = 64000;
  7.     break;
  8. }

All we are doing is changing to the standard 320×200 video mode and calling our Unchain function that turns the memory arrangement from normal Linear to Unchained! Remember that since we are changing the way video ram is organized, we have to modify the way we move our offscreen buffer to Vram and also how we directly draw pixels to the screen.

320×240 Unchained

C [Show Plain Code]:
  1. case 240:
  2. {
  3.     VideoMode(0×13); 
  4.     Unchain();
  5.     asm("movw $0x3c2,%%dx
  6.          movb $0xe3,%%ax
  7.          out %%ax,%%dx
  8.                   
  9.          movw $0x3d4,%%dx
  10.          movw $0x2c11,%%ax
  11.          out %%ax,%%dx
  12.                   
  13.          movw $0x0d06,%%ax
  14.          out %%ax,%%dx
  15.                                 
  16.          movw $0x3e07,%%ax
  17.          out %%ax,%%dx
  18.                                       
  19.          movw $0xea10,%%ax
  20.          out %%ax,%%dx
  21.                                 
  22.          movw $0xac11,%%ax
  23.          out %%ax,%%dx
  24.                               
  25.          movw $0xdf12,%%ax
  26.          out %%ax,%%dx
  27.                               
  28.          movw $0xe715,%%ax
  29.          out %%ax,%%dx
  30.                 
  31.          movw $0×0616,%%ax
  32.          out %%ax,%%dx"
  33.        :
  34.        :
  35.        :"%ax","%dx");
  36.        Screen_Height=240;
  37.        Screen_Size = 76800;
  38.        break;
  39. }

or normal C++

C [Show Plain Code]:
  1. case 240:
  2. {
  3.     VideoMode(0×13);   
  4.     Unchain();
  5.     outpb(0x3c2,0xe3);   //Create Square Pixel Aspect Ratio
  6.     outpw(0x3d4,0x2c11); //Turn Off Write Protect
  7.     outpw(0x3d4,0x0d06); //Vertical Total
  8.     outpw(0x3d4,0x3e07); //Overflow Register
  9.     outpw(0x3d4,0xea10); //Vertical Retrace Start
  10.     outpw(0x3d4,0xac11); //Vertical Retrace End AND Write Protect
  11.     outpw(0x3d4,0xdf12); //Vertical Display Enable End
  12.     outpw(0x3d4,0xe715); //Start Vertical Blanking
  13.     outpw(0x3d4,0×0616); //End Vertical Blanking
  14.     Screen_Height=240;
  15.     Screen_Size = 76800;
  16.     break;
  17. }

If you really want to know what’s going on please read the remarks next to the C++ version of this mode. The nice thing is that we can forget what this is doing and just use it!


320×400 Unchained

C [Show Plain Code]:
  1. case 400:
  2. {
  3.     VideoMode(0×13);   
  4.     Unchain();
  5.     asm(" movw $0x3d4,%%dx
  6.           movw $0×4009,%%ax
  7.           out %%ax,%%dx"
  8.          :
  9.          :
  10.          :"%ax","%dx");
  11.    
  12.     Screen_Height = 400;
  13.     Screen_Size =  12800;
  14.     break;
  15. }

or Normal C++

C [Show Plain Code]:
  1. case 400:
  2. {
  3.     VideoMode(0×13);
  4.     Unchain();
  5.     outp(0x3d4,0×4009);
  6.     Screen_Height = 400;
  7.     Screen_Size = 12800;
  8.     break;
  9. }

This is pretty darn easy huh! All we are doing now is communicating with CRTC Register 9. Bits 0-4 tell it how many scan lines to use -1. This is the same thing we did to achieve 320×100 except we are writing a different value to the same port!


320×480 Unchained

C [Show Plain Code]:
  1. case 480:
  2. {
  3.     VideoMode(0×13); 
  4.     Unchain();
  5.     asm("movw $0x3c2,%%dx
  6.          movb $0xe3,%%ax
  7.          out %%ax,%%dx
  8.                   
  9.          movw $0x3d4,%%dx
  10.          movw $0x2c11,%%ax
  11.          out %%ax,%%dx
  12.                   
  13.          movw $0x0d06,%%ax
  14.          out %%ax,%%dx
  15.                                 
  16.          movw $0x3e07,%%ax
  17.          out %%ax,%%dx
  18.                                       
  19.          movw $0xea10,%%ax
  20.          out %%ax,%%dx
  21.                                 
  22.          movw $0xac11,%%ax
  23.          out %%ax,%%dx
  24.                               
  25.          movw $0xdf12,%%ax
  26.          out %%ax,%%dx
  27.                               
  28.          movw $0xe715,%%ax
  29.          out %%ax,%%dx
  30.                   
  31.          movw $0×0616,%%ax
  32.          out %%ax,%%dx
  33.                 
  34.          movw $0×4009,%%ax
  35.          out %%ax,%%dx"
  36.         :
  37.         :
  38.         :"%ax","%dx");
  39.         Screen_Height=480;
  40.         Screen_Size = 153600;
  41.         break;
  42. }

or normal C++

C [Show Plain Code]:
  1. case 480:
  2. {
  3.     VideoMode(0×13);   //320×480 unchained
  4.     Unchain();
  5.     outpb(0x3c2,0xe3);
  6.     outpw(0x3d4,0x2c11);
  7.     outpw(0x3d4,0x0d06);
  8.     outpw(0x3d4,0x3e07);
  9.     outpw(0x3d4,0xea10);
  10.     outpw(0x3d4,0xac11);
  11.     outpw(0x3d4,0xdf12);
  12.     outpw(0x3d4,0xe715);
  13.     outpw(0x3d4,0×0616);
  14.     outpw(0x3d4,0×4009);
  15.     Screen_Height = 480;
  16.     Screen_Size = 153600;
  17.     break;
  18. }

Here we are just going into normal 320x200x256 mode, unchaining memory, changing to 320×240 and using our little scheme we learned to achieve 320×100 to double our resolution to 320×480.

Leave a Reply

Your email address will not be published. Required fields are marked *

*

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>