测试VGA12H直接写屏速度

最新推荐文章于 2022-05-21 16:46:59 发布
最新推荐文章于 2022-05-21 16:46:59 发布
阅读量2.5k 收藏 1
点赞数
分类专栏： 微机原理、DOS、BIOS与硬件接口编程 文章标签： 测试 byte video fp windows c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyl910/article/details/1384571
版权

File:      VGASpeed.txt
Name:      测试VGA12H模式的速度
Author:    zyl910
Blog:      http://blog.csdn.net/zyl910/
Version:   V1.0
Updata:    2006-11-14

下载（注意修改下载后的扩展名）


简介
~~~~
　　DOS下直接写屏的代码写过不少了，但一直没有想过一个问题——操作VGA的速度有多块。因此，我写了个小程序来测试VGA的速度。
　　图形模式：VGA 12h，640*480*16色。
　　三个测试项目：
　　　　1.读测试。使用VGA读模式0，逐扫描行逐位平面的将显存数据复制到系统内存。
　　　　2.写测试。使用VGA写模式0，逐扫描行逐位平面的将系统内存数据复制到显存。
　　　　3.在等待垂直回扫情况下的写测试。
　　四种访问方式：用C语言远指针、movsb、movsw、movsd

 

测试结果
~~~~~~~~

CPU 　　: AMD Athlon XP 1700+（实际频率：1463 MHz (11 x 133)）
内存　　: DDR266 256MB
显卡　　: NVIDIA GeForce2 MX/MX 400（AGP 4X）
显存带宽: 125MHz * 128bit = 2000MB/s
操作系统: Windows XP SP2
[FPS]
R_C    :         11.7646
W_C    :         51.5834
R_BYTE :         12.0000
W_BYTE :         86.4751
R_WORD :         23.6298
W_WORD :        124.8862
R_DWORD:         44.7459
W_DWORD:        156.8619
WaitW_B:         60.0298
WaitW_W:         59.9293
WaitW_D:         59.9293
124.8862 /  86.4751 = 144.42%
156.8619 / 124.8862 = 125.60%

 

CPU 　　: AMD Athlon XP 1700+（实际频率：1463 MHz (11 x 133)）
内存　　: DDR266 256MB
显卡　　: NVIDIA GeForce2 MX/MX 400（AGP 4X）
显存带宽: 125MHz * 128bit = 2000MB/s
操作系统: Windows 98SE
[FPS]
R_C    :         11.6641
W_C    :         60.7337
R_BYTE :         11.9657
W_BYTE :         98.8431
R_WORD :         23.4287
W_WORD :        173.9558
R_DWORD:         44.4442
W_DWORD:        267.9724
WaitW_B:         59.9293
WaitW_W:         59.9293
WaitW_D:         60.0298
173.9558 /  98.8431 = 175.99%
267.9724 / 173.9558 = 154.05%


CPU 　　: AMD Athlon XP 1700+（实际频率：1463 MHz (11 x 133)）
内存　　: DDR266 256MB
显卡　　: NVIDIA GeForce2 MX/MX 400（AGP 4X）
显存带宽: 125MHz * 128bit = 2000MB/s
操作系统: DOS实模式
[FPS]
R_C    :         11.7646
W_C    :         61.2365
R_BYTE :         12.0663
W_BYTE :        107.9934
R_WORD :         23.6298
W_WORD :        190.6475
R_DWORD:         44.9470
W_DWORD:        279.1337
WaitW_B:         60.0298
WaitW_W:         59.9293
WaitW_D:         60.0298
190.6475 / 107.9934 = 176.54%
279.1337 / 190.6475 = 146.41%

 

CPU 　　: Intel Celeron 2.53GHz
内存　　: Dual DDR333 512MB
显卡　　: NVIDIA RIVA TNT2 Model 64（AGP 4X）
显存带宽: 110MHz * 64bit = 880MB/s
操作系统: Windows XP SP2
[FPS]
R_C    :          8.4464
W_C    :         37.5061
R_BYTE :          8.4000
W_BYTE :         46.1536
R_WORD :         16.2895
W_WORD :         64.1525
R_DWORD:         31.1713
W_DWORD:         78.9337
WaitW_B:         29.8641
WaitW_W:         59.3260
WaitW_D:         59.5271
64.1525 / 46.1536 = 138.99%
78.9337 / 64.1525 = 123.04%

 

CPU 　　: Intel Celeron, 1800 MHz (18 x 100)
内存　　: DDR266 256MB
显卡　　: nVIDIA GeForce4 MX 440（AGP 8X）
显存带宽: 405MHz * 64bit = 3240MB/s
操作系统: Windows XP SP2
[FPS]
R_C    :          7.7425
W_C    :         33.1823
R_BYTE :          7.8000
W_BYTE :         42.9359
R_WORD :         15.0829
W_WORD :         56.5105
R_DWORD:         28.8586
W_DWORD:         68.5768
WaitW_B:         28.6575
WaitW_W:         49.2707
WaitW_D:         55.2033
56.5105 / 42.9359 = 131.62%
68.5768 / 56.5105 = 121.35%

 

分析
~~~~

一、刷新率是60帧
　　“在等待垂直回扫情况下的写测试”的测试结果都差不多，这表示VGA12H模式下的刷新率为60帧。


二、读的速度比写的慢的多
　　可能是因为在设计VGA硬件时，考虑到显存一般是用来输出的，所以专门为写操作优化的。
　　由于读速度过慢，所以VGA的一些需要读显存的硬件加速特性——循环移位、位图合并模式——并不能提高性能，反而有可能拖后腿。


三、movsw/movsd对性能的提升没有想象中得那么高
　　对于读测试，movsw/movsd能使性能翻倍。
　　可对于写测试，movsw/movsd虽然能提高性能，但并没翻倍。
　　但是我们为了追求速度，还是坚持使用movsd方式吧。
　　注意写模式1只支持movsb。


四、为什么速度这么慢
　　VGA12H模式的分辨率是640*480*16色，所以每帧图像大小为：640*480*4/8 = 153600(Byte)
　　AGP总线的频率为66Mhz，如果每个时钟复制一个字节，那么理论上的帧率为：66Mhz * 1BytePerHz / 153600 = 429.6875fps
　　而实际的movsb的测试结果是100帧左右，只有理论值的1/4。若再考虑AGP 4X使频率提高4倍，那么差距更大。
　　可能是因为：当显卡将帧数据发送到显示器时，不可访问主表面的显存。但是VGA12H下只有一个主表面（VGA显存是256KB），放不下离屏表面，无法利用双缓冲加速。


测试代码
~~~~~~~~

  

/*
File:      VGASpeed.c
Name:      测试VGA12H模式的速度
Author:    zyl910
Blog:      http://blog.csdn.net/zyl910/
Version:   V1.0
Updata:    2006-11-14
*/
#include <stdio.h>
#include <conio.h>
#include <mem.h>
#include <dos.h>

typedef unsigned char BYTE;
typedef unsigned int  WORD;
typedef unsigned long DWORD;
typedef void far* LPVOID;

#define SCR_W 640
#define SCR_H 480
#define SCR_PLANES 4
#define SCANSIZE_DIB ((SCR_W)/2)
#define SCANSIZE_VGA ((SCR_W)/8)
#define SEG_VIDEO 0xA000
#define WaitVR() while(!(inportb(0x3da)&0x08))
static volatile DWORD far* const pbiosclock = MK_FP(0x0040, 0x6C);
#define BIOSCLOCK_F ((double)18.2)
void repmovsb(LPVOID lpD, LPVOID lpS, WORD cBytes)
{
 _asm{
  push ds
  push es
  mov cx, cBytes
  les di, lpD
  lds si, lpS
  rep movsb
  pop es
  pop ds;
 }
}
void repmovsw(LPVOID lpD, LPVOID lpS, WORD cWords)
{
 _asm{
  push ds
  push es
  mov cx, cWords
  les di, lpD
  lds si, lpS
  rep movsw
  pop es
  pop ds;
 }
}
void repmovsd(LPVOID lpD, LPVOID lpS, WORD cDWords)
{
 _asm{
  push ds
  push es
  mov cx, cDWords
  les di, lpD
  lds si, lpS
  db 0x66; rep movsw; /* rep movsd */
  pop es
  pop ds
 }
}
int main(void)
{
 BYTE byVGA[SCR_PLANES][SCANSIZE_VGA];
 DWORD cntF;
 int iX, iY;
 BYTE iP;
 WORD pscan;
 BYTE far *pbyV;
 BYTE *pbyM;
 BYTE bymask;
 DWORD tmrold, tmrcur, tmrover;
 double fpsR_C, fpsR_BYTE, fpsR_WORD, fpsR_DWORD;
 double fpsW_C, fpsW_BYTE, fpsW_WORD, fpsW_DWORD;
 double fpsWaitW_BYTE, fpsWaitW_WORD, fpsWaitW_DWORD;
 /* init VGA 12h: 640*480*4bit */
 _asm{
  mov ax, 0x0012;
  int 0x10;
  cld;
 }
 printf("Testing...");
 /* R:C */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   pscan = 0;
   for(iY=0; iY<SCR_H; iY++)
   {
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3CE; /* gc[4]:Read Map Select */
      mov al, 4;
      out dx, al;
      inc dx;
      mov al, iP;
      out dx, al;
     }
     pbyM = byVGA[iP];
     pbyV = MK_FP(SEG_VIDEO, pscan);
     for(iX=0; iX<SCANSIZE_VGA; iX++)
     {
      *pbyM++ = *pbyV++;
     }
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsR_C = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* W:C */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   memset(byVGA[0], -(1&(((int)cntF)>>0)), SCANSIZE_VGA);
   memset(byVGA[1], -(1&(((int)cntF)>>1)), SCANSIZE_VGA);
   memset(byVGA[2], -(1&(((int)cntF)>>2)), SCANSIZE_VGA);
   memset(byVGA[3], -(1&(((int)cntF)>>3)), SCANSIZE_VGA);
   pscan = 0;
   for(iY=0; iY<SCR_H; iY++)
   {
    bymask = 1;
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3C4; /* sc[2]:Map Mask */
      mov al, 2;
      out dx, al;
      inc dx;
      mov al, bymask;
      out dx, al;
     }
     pbyM = byVGA[iP];
     pbyV = MK_FP(SEG_VIDEO, pscan);
     for(iX=0; iX<SCANSIZE_VGA; iX++)
     {
      *pbyV++ = *pbyM++;
     }
     bymask <<= 1;
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsW_C = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* R:Byte */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   pscan = 0;
   for(iY=0; iY<SCR_H; iY++)
   {
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3CE; /* gc[4]:Read Map Select */
      mov al, 4;
      out dx, al;
      inc dx;
      mov al, iP;
      out dx, al;
     }
     repmovsb(byVGA[iP], MK_FP(SEG_VIDEO, pscan), SCANSIZE_VGA);
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsR_BYTE = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* W:BYTE */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   memset(byVGA[0], -(1&(((int)cntF)>>0)), SCANSIZE_VGA);
   memset(byVGA[1], -(1&(((int)cntF)>>1)), SCANSIZE_VGA);
   memset(byVGA[2], -(1&(((int)cntF)>>2)), SCANSIZE_VGA);
   memset(byVGA[3], -(1&(((int)cntF)>>3)), SCANSIZE_VGA);
   pscan = 0;
   for(iY=0; iY<SCR_H; iY++)
   {
    bymask = 1;
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3C4; /* sc[2]:Map Mask */
      mov al, 2;
      out dx, al;
      inc dx;
      mov al, bymask;
      out dx, al;
     }
     repmovsb(MK_FP(SEG_VIDEO, pscan), byVGA[iP], SCANSIZE_VGA);
     bymask <<= 1;
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsW_BYTE = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* R:Word */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   pscan = 0;
   for(iY=0; iY<SCR_H; iY++)
   {
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3CE; /* gc[4]:Read Map Select */
      mov al, 4;
      out dx, al;
      inc dx;
      mov al, iP;
      out dx, al;
     }
     repmovsw(byVGA[iP], MK_FP(SEG_VIDEO, pscan), SCANSIZE_VGA/2);
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsR_WORD = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* W:WORD */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   memset(byVGA[0], -(1&(((int)cntF)>>0)), SCANSIZE_VGA);
   memset(byVGA[1], -(1&(((int)cntF)>>1)), SCANSIZE_VGA);
   memset(byVGA[2], -(1&(((int)cntF)>>2)), SCANSIZE_VGA);
   memset(byVGA[3], -(1&(((int)cntF)>>3)), SCANSIZE_VGA);
   pscan = 0;
   for(iY=0; iY<SCR_H; iY++)
   {
    bymask = 1;
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3C4; /* sc[2]:Map Mask */
      mov al, 2;
      out dx, al;
      inc dx;
      mov al, bymask;
      out dx, al;
     }
     repmovsw(MK_FP(SEG_VIDEO, pscan), byVGA[iP], SCANSIZE_VGA/2);
     bymask <<= 1;
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsW_WORD = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* R:DWord */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   pscan = 0;
   for(iY=0; iY<SCR_H; iY++)
   {
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3CE; /* gc[4]:Read Map Select */
      mov al, 4;
      out dx, al;
      inc dx;
      mov al, iP;
      out dx, al;
     }
     repmovsd(byVGA[iP], MK_FP(SEG_VIDEO, pscan), SCANSIZE_VGA/4);
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsR_DWORD = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* W:DWORD */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   memset(byVGA[0], -(1&(((int)cntF)>>0)), SCANSIZE_VGA);
   memset(byVGA[1], -(1&(((int)cntF)>>1)), SCANSIZE_VGA);
   memset(byVGA[2], -(1&(((int)cntF)>>2)), SCANSIZE_VGA);
   memset(byVGA[3], -(1&(((int)cntF)>>3)), SCANSIZE_VGA);
   pscan = 0;
   for(iY=0; iY<SCR_H; iY++)
   {
    bymask = 1;
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3C4; /* sc[2]:Map Mask */
      mov al, 2;
      out dx, al;
      inc dx;
      mov al, bymask;
      out dx, al;
     }
     repmovsd(MK_FP(SEG_VIDEO, pscan), byVGA[iP], SCANSIZE_VGA/4);
     bymask <<= 1;
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsW_DWORD = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* WaitW:BYTE */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   memset(byVGA[0], -(1&(((int)cntF)>>0)), SCANSIZE_VGA);
   memset(byVGA[1], -(1&(((int)cntF)>>1)), SCANSIZE_VGA);
   memset(byVGA[2], -(1&(((int)cntF)>>2)), SCANSIZE_VGA);
   memset(byVGA[3], -(1&(((int)cntF)>>3)), SCANSIZE_VGA);
   pscan = 0;
   WaitVR();
   for(iY=0; iY<SCR_H; iY++)
   {
    bymask = 1;
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3C4; /* sc[2]:Map Mask */
      mov al, 2;
      out dx, al;
      inc dx;
      mov al, bymask;
      out dx, al;
     }
     repmovsb(MK_FP(SEG_VIDEO, pscan), byVGA[iP], SCANSIZE_VGA);
     bymask <<= 1;
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsWaitW_BYTE = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* WaitW:WORD */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   memset(byVGA[0], -(1&(((int)cntF)>>0)), SCANSIZE_VGA);
   memset(byVGA[1], -(1&(((int)cntF)>>1)), SCANSIZE_VGA);
   memset(byVGA[2], -(1&(((int)cntF)>>2)), SCANSIZE_VGA);
   memset(byVGA[3], -(1&(((int)cntF)>>3)), SCANSIZE_VGA);
   pscan = 0;
   WaitVR();
   for(iY=0; iY<SCR_H; iY++)
   {
    bymask = 1;
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3C4; /* sc[2]:Map Mask */
      mov al, 2;
      out dx, al;
      inc dx;
      mov al, bymask;
      out dx, al;
     }
     repmovsw(MK_FP(SEG_VIDEO, pscan), byVGA[iP], SCANSIZE_VGA/2);
     bymask <<= 1;
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsWaitW_WORD = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* WaitW:DWORD */
 do{
  cntF = 0;
  tmrold = *pbiosclock;
  tmrover = tmrold + (DWORD)(BIOSCLOCK_F * 10); /* 10s */
  do{
   memset(byVGA[0], -(1&(((int)cntF)>>0)), SCANSIZE_VGA);
   memset(byVGA[1], -(1&(((int)cntF)>>1)), SCANSIZE_VGA);
   memset(byVGA[2], -(1&(((int)cntF)>>2)), SCANSIZE_VGA);
   memset(byVGA[3], -(1&(((int)cntF)>>3)), SCANSIZE_VGA);
   pscan = 0;
   WaitVR();
   for(iY=0; iY<SCR_H; iY++)
   {
    bymask = 1;
    for(iP=0; iP<SCR_PLANES; iP++)
    {
     _asm{
      mov dx, 0x3C4; /* sc[2]:Map Mask */
      mov al, 2;
      out dx, al;
      inc dx;
      mov al, bymask;
      out dx, al;
     }
     repmovsd(MK_FP(SEG_VIDEO, pscan), byVGA[iP], SCANSIZE_VGA/4);
     bymask <<= 1;
    }
    pscan += SCANSIZE_VGA;
   }
   cntF++;
   tmrcur = *pbiosclock;
  }while((tmrcur<tmrover)&&(tmrcur>=tmrold));
  if (tmrcur < tmrold) continue;
 }while(0);
 fpsWaitW_DWORD = cntF / ((tmrcur-tmrold)/BIOSCLOCK_F);
 /* Exit VGA */
 _asm{
  mov ax, 0x0003;
  int 0x10;
 }
 /* out */
 printf("[FPS]/n");
 printf("R_C    :%16.4f/n", fpsR_C);
 printf("W_C    :%16.4f/n", fpsW_C);
 printf("R_BYTE :%16.4f/n", fpsR_BYTE);
 printf("W_BYTE :%16.4f/n", fpsW_BYTE);
 printf("R_WORD :%16.4f/n", fpsR_WORD);
 printf("W_WORD :%16.4f/n", fpsW_WORD);
 printf("R_DWORD:%16.4f/n", fpsR_DWORD);
 printf("W_DWORD:%16.4f/n", fpsW_DWORD);
 printf("WaitW_B:%16.4f/n", fpsWaitW_BYTE);
 printf("WaitW_W:%16.4f/n", fpsWaitW_WORD);
 printf("WaitW_D:%16.4f/n", fpsWaitW_DWORD);
 return 0;
}

zyl910
关注
专栏目录
国产化系统中遇到的视频花屏、卡顿以及延迟问题的记录与总结
dvlinker的技术专栏
03-21 3万+
国产化系统中遇到的视频花屏、卡顿以及延迟问题的记录与总结。
图像显示(1)RGB接口
最新发布
余生芳华，灵魂共舞
11-03 774
介绍TFT、LCD、VGA的概念与相互关系；介绍并实现RGB接口时序完成TFT显示。
VGA12h与VGA寄存器
weixin_34032792的博客
03-08 180
lingix 和 libsvga 切换到vga12h的方法有所不同.lingix 12h模式的vga reg dump是unsigned char g_640x480x16[] = { /* MISC */ 0xE3, /* SEQ */ 0x03, 0x01, 0x08, 0x00, 0x06, /* CRTC */ 0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0...
测试VGA12H直接写屏速度 V1.1
zyl910的专栏
11-23 2385
File:      VGASpeed.txtName:      测试VGA12H模式的速度Author:    zyl910Blog:      http://blog.csdn.net/zyl910/Version:   V1.1Updata:    2006-11-23下载（注意修改下载后的扩展名）　　经过上一次的测试后，发现读显存的速度比写显存的速度慢得多。　　很多资料建议我们使
当年我QB的封笔之作——在VGA 12h 模式下实时抖动绘制真彩色数据
zyl910的专栏
05-29 3642
当年我QB的封笔之作——在VGA 12h 模式下实时抖动绘制真彩色数据View RGB作者：zyl910使用有序抖动算法（dither）绘制线性渐变区域、RGB色彩空间（Screen 12下） Up , Down , PageUp , PageDown: 改变B分量 F4~F8: 改变背景 Esc: 退出直接在QB环境下运行速度很慢，编译为exe后就快些了展示了以下技术
Turbo C使用的汇编函数 -- VGA 12H模式图形函数（一）
sogotobj
09-15 245
上次整理以前DOS下的代码，找了个线性回归分析函数，觉得可能还有用，于是放在了《C语言版的线性回归分析函数》中，今天在CSDN的C/C++版，发现居然还有人求DOS下VGA 12H模式下的直接写屏代码，临时找了2个以前的文件，发了出去供参考。后来仔细找了一会，把以前DOS下写的供Trubo C使用的VGA 12H直接写屏图形函数找齐了，还有鼠标和XMS内存管理函数，决定放在这里，供C语言初学者参...
简单的VGA字符模式驱动（二）
满天星专栏
08-12 3136
上节介绍了访问VGA显卡显存的方法。现在我们要在屏幕上设置光标了。光标和显存不一样。它必须通过显卡的I/O端口开控制。 VGA显卡内部有一系列寄存器可以用来控制显卡的状态。在标准的PC机上。 0x3d4和0x3d5两个端口可以用来读写显卡的内部寄存器。方法是先向0x3d4端口写入要访问的寄存器编号，再通过0x3d5端口来读写寄存器数据。存放光标位置的寄存器编号为14和15。两个寄存器合起来
【FPGA实验】基于DE2-115平台的VGA显示
qq_45659777的博客
05-21 4019
文章目录一.VGA介绍二.VGA显示字符参考链接： 一.VGA介绍 VGA（Video Graphics Array）视频图形阵列是IBM于1987年提出的一个使用模拟信号的电脑显示标准。VGA接口即电脑采用VGA标准输出数据的专用接口。VGA接口共有15针，分成3排，每排5个孔，显卡上应用最为广泛的接口类型，绝大多数显卡都带有此种接口。它传输红、绿、蓝模拟信号以及同步信号(水平和垂直信号)。 VGA接口是一种D型接口，上面共有15针孔，分成三排，每排五个。 其中，除了2根NC（Not Connect)信号
基于S3c2440的多种显示屏测试方案
uffgfbft的博客
01-30 829
基于S3c2440的多种显示屏测试方案
VGA寄存器一览表
weixin_33860722的博客
03-05 525
VGA寄存器地址表 寄存器名称 单色显示模式 彩色显示模式 混合输出寄存器     3C2H 3C2H     (VGA读端口3CCH) 待征控制寄存器 3BAH 3DAH (VGA读端口3CAH) 输入状态寄存器 3C2H 3C2H 输入状态寄存器1 3BAH 3DAH VGA允...
汇编语言rep movsd 的使用详解
12-25
mov esi，offset @s1mov edi，offset @s2 mov ecx，10cld rep movsd 1.rep movsd 每次ecx！=0便执行movsd ，然后ecx=ecx-1 movsd移动ds：[si] 到es：[di]，在32位汇编下可以用esi代替si，edi代替di 2.同时由于在一般exe中ds = es 程序起始位置所以另esi = offset @s1就可以找到变量s1 ,edi= offset @s2就可以找到变量s2 3.movsd此类指令有个性质，当标志位d=0时执行一次esi = esi +1,edi= edi+ 1      d=1时
自己动手写操作系统时遇到的关于VGA显示的疑问
kjkljkjlj
10-19 1693
在自己动手写操作系统时，遇到了关于显示几个问题，经几方搜寻和思索，将理解作大致记录。 显示器是一个设备，显卡是一个设备，显卡控制显示器进行显示。 cpu是一个设备，cpu可以对显卡进行读写和配置。 cpu对显卡的配置与显示器无关。 x86汇编能调用中断进行显示是因为bios里有中断处理程序，如果这个程序只是按vga接口编的，那这台电脑就不能使用其它显示接口（如果自己写，能够
VGA信号详解
热门推荐
kindlyde
08-17 4万+
最近做了一些关于视频的工作，稍微研究了一下V4L2和硬件上的视频知识，其中包括了VGA、component、PAL等信号。在这里总结一下关于VGA信号波形方面的知识。    在学习VGA的视频输出的时候，很容易就可以从网上找到相关的引脚定义： 1 　　　　   红色视频信号　　　　　　(Red, 75 ohm, 0.7 V p-p) 2    　　  
VGA/DVI/HDMI/DP接口知识全详解
biao197的专栏
09-19 2万+
VGA接口知识详解 VGA（Video Graphics Array）视频图形阵列，是IBM在1987年推出的一种视频传输标准，具有分辨率高、显示速率快、颜色丰富等优点，在彩色显示器领域得到了广泛的应用。VGA接口是电脑采用VGA标准输出数据的专用接口。VGA接口共有15针，分成3排，每排5个孔，显卡上应用最为广泛的接口类型，绝大多数显卡都带有此种接口。它传输红、绿、蓝模拟信号以及同步信号(水平...
VGA接口原理图
ctthuangcheng
01-29 5288
FPGA-08FPGAVGA彩条显示
特别的猫
08-31 3118
（1）VGA简介 VGA的全称是Video Graphics Array，即视频图形阵列，是一个使用模拟信号进行视频传输的标准。早期的CRT显示器由于设计制造上的原因，只能接收模拟信号输入，因此计算机内部的显卡负责进行数模转换，而VGA接口就是显卡上输出模拟信号的接口。如今液晶显示器虽然可以直接接收数字信号，但是为了兼容显卡上的VGA接口，也大都支持VGA标准。 在VGA视频传输标准...
电脑各种常用接口数据传输速率大全
JiangDong的博客
03-19 1万+
接口传输速率接口类型传输速率（GB/s）类型版本USBUSB1.10.12USB2.00.48USB3.05USB3.1 gen15USB3.1 gen210HDMIHDMI1.14.95HDMI1.24.95HDMI1.310.2HDMI1.410.2HDMI2.018DisplayPortDisplayPort1.110.8DisplayPort1.221.6DisplayPort1.332....
VM5000：详解VGA接口测试与应用
本文档主要介绍了如何使用VM5000测试VGA接口及其相关知识。VGA全称为Video Graphics Array，是一种图形控制器标准，由IBM在1987年随着PS/2个人电脑推出，用于驱动传统的模拟显示器。它解决了早期计算机显示器颜色和...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值