#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>
static GLsizei MaxSize = 2048;
static GLsizei TexWidth = 1024, TexHeight = 1024, TexBorder = 0;
static GLboolean ScaleAndBias = GL_FALSE;
static GLboolean SubImage = GL_FALSE;
static GLdouble DownloadRate = 0.0;
static GLuint Mode = 0;
#define NR_TEXOBJ 4
static GLuint TexObj[NR_TEXOBJ];
struct FormatRec {
GLenum Format;
GLenum Type;
GLenum IntFormat;
GLint TexelSize;
};
static const struct FormatRec FormatTable[] = {
{ GL_BGRA, GL_UNSIGNED_BYTE, GL_RGBA, 4 },
{ GL_RGB, GL_UNSIGNED_BYTE, GL_RGB, 3 },
{ GL_RGBA, GL_UNSIGNED_BYTE, GL_RGBA, 4 },
{ GL_RGBA, GL_UNSIGNED_BYTE, GL_RGB, 4 },
{ GL_RGB, GL_UNSIGNED_SHORT_5_6_5, GL_RGB, 2 },
{ GL_LUMINANCE, GL_UNSIGNED_BYTE, GL_LUMINANCE, 1 },
{ GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, GL_LUMINANCE_ALPHA, 2 },
{ GL_ALPHA, GL_UNSIGNED_BYTE, GL_ALPHA, 1 },
};
static GLint Format;
#define NUM_FORMATS (sizeof(FormatTable)/sizeof(FormatTable[0]))
static int
BytesPerTexel(GLint format)
{
return FormatTable[format].TexelSize;
}
static const char *
FormatStr(GLenum format)
{
switch (format) {
case GL_RGB:
return "GL_RGB";
case GL_RGBA:
return "GL_RGBA";
case GL_BGRA:
return "GL_BGRA";
case GL_LUMINANCE:
return "GL_LUMINANCE";
case GL_LUMINANCE_ALPHA:
return "GL_LUMINANCE_ALPHA";
case GL_ALPHA:
return "GL_ALPHA";
default:
return "";
}
}
static const char *
TypeStr(GLenum type)
{
switch (type) {
case GL_UNSIGNED_BYTE:
return "GL_UNSIGNED_BYTE";
case GL_UNSIGNED_SHORT:
return "GL_UNSIGNED_SHORT";
case GL_UNSIGNED_SHORT_5_6_5:
return "GL_UNSIGNED_SHORT_5_6_5";
case GL_UNSIGNED_SHORT_5_6_5_REV:
return "GL_UNSIGNED_SHORT_5_6_5_REV";
default:
return "";
}
}
#define ALIGN (1<<12)
static unsigned long align(unsigned long value, unsigned long a)
{
return (value + a - 1) & ~(a-1);
}
static int MIN2(int a, int b)
{
return a < b ? a : b;
}
static void
MeasureDownloadRate(void)
{
const int w = TexWidth + 2 * TexBorder;
const int h = TexHeight + 2 * TexBorder;
const int image_bytes = align(w * h * BytesPerTexel(Format), ALIGN);
const int bytes = image_bytes * NR_TEXOBJ;
GLubyte *orig_texImage, *orig_getImage;
GLubyte *texImage, *getImage;
GLdouble t0, t1, time;
int count;
int i;
int offset = 0;
GLdouble total = 0;
printf("allocating %d bytes for %d %dx%d images\n",
bytes, NR_TEXOBJ, w, h);
orig_texImage = (GLubyte *) malloc(bytes + ALIGN);
orig_getImage = (GLubyte *) malloc(image_bytes + ALIGN);
if (!orig_texImage || !orig_getImage) {
DownloadRate = 0.0;
return;
}
printf("alloc %p %p\n", orig_texImage, orig_getImage);
texImage = (GLubyte *)align((unsigned long)orig_texImage, ALIGN);
getImage = (GLubyte *)align((unsigned long)orig_getImage, ALIGN);
for (i = 1; !(((unsigned long)texImage) & i); i<<=1)
;
printf("texture image alignment: %d bytes (%p)\n", i, texImage);
for (i = 0; i < bytes; i++) {
texImage[i] = i & 0xff;
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
if (ScaleAndBias) {
glPixelTransferf(GL_RED_SCALE, 0.5);
glPixelTransferf(GL_GREEN_SCALE, 0.5);
glPixelTransferf(GL_BLUE_SCALE, 0.5);
glPixelTransferf(GL_RED_BIAS, 0.5);
glPixelTransferf(GL_GREEN_BIAS, 0.5);
glPixelTransferf(GL_BLUE_BIAS, 0.5);
}
else {
glPixelTransferf(GL_RED_SCALE, 1.0);
glPixelTransferf(GL_GREEN_SCALE, 1.0);
glPixelTransferf(GL_BLUE_SCALE, 1.0);
glPixelTransferf(GL_RED_BIAS, 0.0);
glPixelTransferf(GL_GREEN_BIAS, 0.0);
glPixelTransferf(GL_BLUE_BIAS, 0.0);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glEnable(GL_TEXTURE_2D);
count = 0;
t0 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
do {
int img = count%NR_TEXOBJ;
GLubyte *img_ptr = texImage + img * image_bytes;
glBindTexture(GL_TEXTURE_2D, TexObj[img]);
if (SubImage && count > 0) {
glTexSubImage2D(GL_TEXTURE_2D, 0,
-TexBorder,
-TexBorder + offset * h/8,
w,
h/8,
FormatTable[Format].Format,
FormatTable[Format].Type,
#if 1
texImage
#else
img_ptr + offset * bytes/8
#endif
);
offset += 1;
offset %= 8;
total += w * h / 8;
}
else {
glTexImage2D(GL_TEXTURE_2D, 0,
FormatTable[Format].IntFormat, w, h, TexBorder,
FormatTable[Format].Format,
FormatTable[Format].Type,
img_ptr);
total += w*h;
}
glBegin(GL_TRIANGLES);
glTexCoord2f(0, 0); glVertex2f(1, 1);
glTexCoord2f(1, 0); glVertex2f(3, 1);
glTexCoord2f(0.5, 1); glVertex2f(2, 3);
glEnd();
t1 = glutGet(GLUT_ELAPSED_TIME) * 0.001;
time = t1 - t0;
count++;
} while (time < 3.0);
glDisable(GL_TEXTURE_2D);
printf("total texels=%f time=%f\n", total, time);
DownloadRate = total / time;
free(orig_texImage);
free(orig_getImage);
{
GLint err = glGetError();
if (err)
printf("GL error %d\n", err);
}
}
static void
PrintString(const char *s)
{
while (*s) {
glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s);
s++;
}
}
static void
Display(void)
{
const int w = TexWidth + 2 * TexBorder;
const int h = TexHeight + 2 * TexBorder;
char s[1000];
glClear(GL_COLOR_BUFFER_BIT);
glRasterPos2i(10, 80);
sprintf(s, "Texture size[cursor]: %d x %d Border[b]: %d", w, h, TexBorder);
PrintString(s);
glRasterPos2i(10, 65);
sprintf(s, "Format[f]: %s Type: %s IntFormat: %s",
FormatStr(FormatTable[Format].Format),
TypeStr( FormatTable[Format].Type),
FormatStr(FormatTable[Format].IntFormat));
PrintString(s);
glRasterPos2i(10, 50);
sprintf(s, "Pixel Scale&Bias[p]: %s TexSubImage[s]: %s",
ScaleAndBias ? "Yes" : "No",
SubImage ? "Yes" : "No");
PrintString(s);
if (Mode == 0) {
glRasterPos2i(200, 10);
sprintf(s, "...Measuring...");
PrintString(s);
glutSwapBuffers();
glutPostRedisplay();
Mode++;
}
else if (Mode == 1) {
MeasureDownloadRate();
glutPostRedisplay();
Mode++;
}
else {
glRasterPos2i(10, 10);
sprintf(s, "Download rate: %g Mtexels/second %g MB/second",
DownloadRate / 1000000.0,
DownloadRate * BytesPerTexel(Format) / 1000000.0);
PrintString(s);
{
GLint r, g, b, a, l, i;
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &r);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_GREEN_SIZE, &g);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_BLUE_SIZE, &b);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_SIZE, &a);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_LUMINANCE_SIZE, &l);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTENSITY_SIZE, &i);
sprintf(s, "TexelBits: R=%d G=%d B=%d A=%d L=%d I=%d", r, g, b, a, l, i);
glRasterPos2i(10, 25);
PrintString(s);
}
glutSwapBuffers();
}
}
static void
Reshape(int width, int height)
{
glViewport( 0, 0, width, height );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho(0, width, 0, height, -1, 1);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
}
static void
Key(unsigned char key, int x, int y)
{
(void) x;
(void) y;
switch (key) {
case ' ':
Mode = 0;
break;
case 'b':
TexBorder = 1 - TexBorder;
Mode = 0;
break;
case 'f':
Format = (Format + 1) % NUM_FORMATS;
Mode = 0;
break;
case 'F':
Format = (Format - 1) % NUM_FORMATS;
Mode = 0;
break;
case 'p':
ScaleAndBias = !ScaleAndBias;
Mode = 0;
break;
case 's':
SubImage = !SubImage;
Mode = 0;
break;
case 27:
exit(0);
break;
}
glutPostRedisplay();
}
static void
SpecialKey(int key, int x, int y)
{
(void) x;
(void) y;
switch (key) {
case GLUT_KEY_UP:
if (TexHeight < MaxSize)
TexHeight *= 2;
break;
case GLUT_KEY_DOWN:
if (TexHeight > 1)
TexHeight /= 2;
break;
case GLUT_KEY_LEFT:
if (TexWidth > 1)
TexWidth /= 2;
break;
case GLUT_KEY_RIGHT:
if (TexWidth < MaxSize)
TexWidth *= 2;
break;
}
Mode = 0;
glutPostRedisplay();
}
static void
Init(void)
{
printf("GL_VENDOR = %s\n", (const char *) glGetString(GL_VENDOR));
printf("GL_VERSION = %s\n", (const char *) glGetString(GL_VERSION));
printf("GL_RENDERER = %s\n", (const char *) glGetString(GL_RENDERER));
}
int
main(int argc, char *argv[])
{
glutInit( &argc, argv );
glutInitWindowPosition( 0, 0 );
glutInitWindowSize( 600, 100 );
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
glutCreateWindow(argv[0]);
glutReshapeFunc( Reshape );
glutKeyboardFunc( Key );
glutSpecialFunc( SpecialKey );
glutDisplayFunc( Display );
Init();
glutMainLoop();
return 0;
}