harness.c

ati driver

						for (; x < dm.virtual_width; x++) {
							fb[x] = 0;
						}
						fb = (uint16 *)((uint8 *)fb + fbc.bytes_per_row);
					}
				} break;
				case B_RGB32_BIG:
				case B_RGBA32_BIG:
				case B_RGB32_LITTLE:
				case B_RGBA32_LITTLE: {
					int x, y;
					uint32 *fb = (uint32 *)fbc.frame_buffer;
					printf(" frame buffer is 32bpp\n");
					/* make a checkerboard pattern */
					for (y = 0; y < (dm.virtual_height >> 1); y++) {
						for (x = 0; x < (dm.virtual_width >> 1); x++) {
							fb[x] = 0;
						}
						for (; x < dm.virtual_width; x++) {
							fb[x] = 0xffffffff;
						}
						fb = (uint32 *)((uint8 *)fb + fbc.bytes_per_row);
					}
					for (; y < dm.virtual_height; y++) {
						for (x = 0; x < (dm.virtual_width >> 1); x++) {
							fb[x] = 0xffffffff;
						}
						for (; x < dm.virtual_width; x++) {
							fb[x] = 0;
						}
						fb = (uint32 *)((uint8 *)fb + fbc.bytes_per_row);
					}
				} break;
				default:
					printf("YIKES! frame buffer shape unknown!\n");
				}
			} break;
			case B_GET_PIXEL_CLOCK_LIMITS: {
				get_pixel_clock_limits gpcl = gah(B_GET_PIXEL_CLOCK_LIMITS, NULL);
				uint32 low, high;
				if (!gpcl) {
					missing_feature(cmds[i]);
					break;
				}
				result = gpcl(&dm, &low, &high);
				if (result != B_OK) {
					printf("get_pixel_clock_limits() failed: %ld (0x%08lx)\n", result, result);
					break;
				}
				printf("Minimum pixel clock: %lu\nMaximum pixel clock: %lu\n", low, high);
			} break;
			case B_MOVE_DISPLAY: {
				move_display_area mda = gah(B_MOVE_DISPLAY, NULL);	/* should we be passing the display mode? */
				int top, left;
				if (mda) {
					printf("Enter new coordinates: "); fflush(stdout);
					scanf("%d,%d", &left, &top);
					/* no range checking for now */
					result = mda(left, top);
					printf("move_display_area() returned %ld (0x%08lx)\n", result, result);
				} else {
					missing_option(cmds[i]);
				}
			} break;
			case B_SET_INDEXED_COLORS: {
				set_indexed_colors sic = gah(B_SET_INDEXED_COLORS, NULL); /* should we be passing display mode */
				if (sic) {
					char *list[] = {"Red CLUT", "Green CLUT", "Blue CLUT", "Grey CLUT", "Be CLUT", NULL};
					int choice;
					choice = pick_from_list("Set cursor visibility:", list);
					if (choice >= 0) {
						uint8 color_data[256 * 3], *cd = color_data;
						int j, k;
						for (j = 0; j < 256; j++) {
							for (k = 0; k < 3; k++) {
								*cd = 0;
								if ((k == choice) || (choice == 3)) *cd = (uint8)j;
								cd++;
							}
						}
						sic(256, 0, color_data, 0);
					}
				} else {
					missing_option(cmds[i]);
				}
			} break;
			case B_ACCELERANT_RETRACE_SEMAPHORE: {
				accelerant_retrace_semaphore ars = gah(B_ACCELERANT_RETRACE_SEMAPHORE, NULL);
				sem_id sid;
				status_t result;
				if (!ars) {
					missing_feature(cmds[i]);
					break;
				}
				sid = ars();
				if (sid < B_OK) {
					printf("Bad semaphore ID returned: %ld\n", sid);
					break;
				}
				if (!valid_mode) {
					printf("No video mode selected, skipping retrace check.\n");
				}
				result = acquire_sem_etc(sid, 1, B_TIMEOUT, 1000000L);
				if (result != B_OK) {
					printf("Semaphore acquisition failed: %ld (0x%08lx)\n", result, result);
					break;
				}
				printf("Retrace semaphore acquired!\n");
			} break;
			case B_SET_CURSOR_SHAPE: {
				if (dm.flags & B_HARDWARE_CURSOR) {
					set_cursor_shape scs = gah(B_SET_CURSOR_SHAPE, NULL);
					if (!scs) {
						missing_option(cmds[i]);
						break;
					}
					{
					int i;
					uint8 hand_and[32];
					for (i = 0; i < 32; i++) hand_and[i] = ~my_hand_cursor_and[i];
					result = scs(16, 16, 2, 2, hand_and, my_hand_cursor_xor);
					}
					if (result != B_OK)
						failed_with_reason("B_SET_CURSOR_SHAPE", result);
				} else printf("Mode does not support hardware cursor!\n");
			} break;
			case B_MOVE_CURSOR: {
				if (dm.flags & B_HARDWARE_CURSOR) {
					move_cursor mc = gah(B_MOVE_CURSOR, NULL);
					if (!mc) {
						missing_option(cmds[i]);
						break;
					}
					mc((uint16)(dm.virtual_width >> 1) - 8, (uint16)(dm.virtual_height >> 1));
				} else printf("Mode does not support hardware cursor!\n");
			} break;
			case B_SHOW_CURSOR: {
				if (dm.flags & B_HARDWARE_CURSOR) {
					show_cursor sc = gah(B_SHOW_CURSOR, NULL);
					char *list[] = {"Hide Cursor", "Show Cursor", NULL};
					int choice;
					if (!sc) {
						missing_option(cmds[i]);
						break;
					}
					choice = pick_from_list("Set cursor visibility:", list);
					if (choice >= 0) sc(choice == 1);
				} else printf("Mode does not support hardware cursor!\n");
			} break;
			case B_ACQUIRE_ENGINE: {
				acquire_engine ae = gah(B_ACQUIRE_ENGINE, NULL);
				if (!ae) {
					missing_feature(cmds[i]);
					break;
				}
				result = ae(0,0, NULL, &et);
				if (result != B_OK) {
					failed_with_reason("acquire_engine()", result);
					et = NULL;
					break;
				}
				engine_acquired = TRUE;
				printf("acceleration engine acquired: 0x%08lx\n", (uint32)et);
			} break;
			case B_RELEASE_ENGINE: {
				release_engine re = gah(B_RELEASE_ENGINE, NULL);
				if (!re) {
					missing_feature(cmds[i]);
					break;
				}
				if (!engine_acquired) {
					printf("Do B_ACQUIRE_ENGINE first!\n");
					break;
				}
				result = re(et, NULL);
				if (result != B_OK) {
					failed_with_reason("release_engine()", result);
					break;
				}
				engine_acquired = FALSE;
				printf("acceleration engine released.\n");
			} break;
			case B_WAIT_ENGINE_IDLE: {
				wait_engine_idle wei = gah(B_WAIT_ENGINE_IDLE, NULL);
				if (!wei) {
					missing_feature(cmds[i]);
					break;
				}
				if (!engine_acquired) {
					printf("Do B_ACQUIRE_ENGINE first!\n");
					break;
				}
				wei();
				printf("Acceleration engine idle.\n");
			} break;
			case B_FILL_RECTANGLE: {
				fill_rectangle rf = gah(B_FILL_RECTANGLE, &dm);
				fill_rect_params rfp[16];
				int j;
				if (!rf) {
					missing_option(cmds[i]);
					break;
				}
				if (!engine_acquired) {
					printf("Do B_ACQUIRE_ENGINE first!\n");
					break;
				}
				rfp[0].left = rfp[0].top = 0;
				rfp[0].right = dm.virtual_width - 1;
				rfp[0].bottom = dm.virtual_height - 1;
				rf(et, 0, rfp, 1);
				for (j = 0; ((dm.virtual_width-1) >> (j+1)) && ((dm.virtual_height-1) >> (j+1)); j++) {
					rfp[j].right = (dm.virtual_width - 1) >> j;
					rfp[j].left = (dm.virtual_width - 1) >> (j+1);
					rfp[j].bottom = (dm.virtual_height - 1) >> j;
					rfp[j].top = (dm.virtual_height - 1) >> (j+1);
					printf("   rfp[%d] = %d,%d to %d,%d\n", j, rfp[j].left, rfp[j].top, rfp[j].right, rfp[j].bottom);
				}
				rf(et, 0xffffffff, rfp, (uint32)j);
			} break;
			case B_INVERT_RECTANGLE: {
				uint16 left, top, right, bottom, h_delta, v_delta;
				fill_rect_params rfp[16];
				int j;
				invert_rectangle ri = gah(B_INVERT_RECTANGLE, &dm);
				if (!ri) {
					missing_option(cmds[i]);
					break;
				}
				if (!engine_acquired) {
					printf("Do B_ACQUIRE_ENGINE first!\n");
					break;
				}
				left = 0; right = dm.virtual_width - 1;
				top = 0; bottom = dm.virtual_height - 1;
				h_delta = dm.virtual_width >> 4;
				v_delta = dm.virtual_height >> 4;
				for (j = 0; j < 8; j++) {
					rfp[j].left = left;
					rfp[j].top = top;
					rfp[j].right = right;
					rfp[j].bottom = bottom;
					left += h_delta;
					right -= h_delta;
					top += v_delta;
					bottom -= v_delta;
				}
				ri(et, rfp, 8);
			} break;
			case B_FILL_SPAN: {
				fill_span sf = gah(B_FILL_SPAN, &dm);
				uint16 *spans, *sp;
				int j, k, w;
				if (!sf) {
					missing_option(cmds[i]);
					break;
				}
				if (!engine_acquired) {
					printf("Do B_ACQUIRE_ENGINE first!\n");
					break;
				}
				sp = spans = (uint16*)calloc(dm.timing.v_display * 3, sizeof(uint16));
				if (!spans) {
					printf("Couldn't allocate RAM for span list :-(\n");
					break;
				}
				for (j = dm.timing.v_display, k = 0, w = dm.timing.h_total >> 1; j > 0; j--) {
					*sp++ = j-1;
					*sp++ = k;
					*sp++ = k + w;
					if (j > dm.timing.v_display / 2) k++;
					else k--;
					if (j & 1) w--;
				}
				sf(et, 0x55555555, spans, dm.timing.v_display);
				free(spans);
			} break;
			
			case B_OVERLAY_COUNT: {
				overlay_count ovc = gah(B_OVERLAY_COUNT, &dm);
				if( !ovc ) {
					missing_option( cmds[i] );
					break;
				}
				printf( "Number of overlay units: %ld\n", ovc( &dm ));
			} break;
			case B_OVERLAY_SUPPORTED_SPACES: {
				overlay_supported_spaces oss = gah(B_OVERLAY_SUPPORTED_SPACES, &dm);
				const uint32 *cur;
				int num, idx;
				
				if( !oss ) {
					missing_option( cmds[i] );
					break;
				}
				overlay_cs = oss( &dm );

				printf( "Supported overlay colour spaces:" );				
				for( cur = overlay_cs, num = 0; *cur; ++cur, ++num )
					printf( " %s", spaceToString( *cur ));
					
				printf( "\n" );
				
				overlay_cs_names = calloc( num + 1, sizeof( char *));
				
				for( idx = 0; idx < num; ++idx  )
					overlay_cs_names[idx] = spaceToString( overlay_cs[idx] );
					
				overlay_cs_names[num] = 0;
			} break;
			case B_OVERLAY_SUPPORTED_FEATURES: {
				overlay_supported_features osf = gah(B_OVERLAY_SUPPORTED_FEATURES, &dm);
				int choice;
				uint32 features;
				if( !osf ) {
					missing_option( cmds[i] );
					break;
				}
				if( overlay_cs == NULL ) {
					printf( "Call B_OVERLAY_SUPPORTED_SPACES first\n" );
					break;
				}
				
				choice = pick_from_list("Choose overlay colour space:", (char **)overlay_cs_names );
				if( choice < 0 )
					break;
				
				features = osf( overlay_cs[choice] );
				printf( "features:" );
				if( features & B_OVERLAY_COLOR_KEY ) printf( " B_OVERLAY_COLOR_KEY" );
				if( features & B_OVERLAY_CHROMA_KEY ) printf( " B_OVERLAY_CHROMA_KEY" );
				if( features & B_OVERLAY_HORIZONTAL_FILTERING ) printf( " B_OVERLAY_HORIZONTAL_FILTERING" );
				if( features & B_OVERLAY_VERTICAL_FILTERING ) printf( " B_OVERLAY_VERTICAL_FILTERING" );
				if( features & B_OVERLAY_HORIZONTAL_MIRRORING ) printf( " B_OVERLAY_HORIZONTAL_MIRRORING" );
				if( features & B_OVERLAY_KEYING_USES_ALPHA ) printf( " B_OVERLAY_KEYING_USES_ALPHA" );
				printf( "\n" );
			} break;
			case B_ALLOCATE_OVERLAY_BUFFER: {
				allocate_overlay_buffer aob = gah(B_ALLOCATE_OVERLAY_BUFFER, &dm);
				int choice;
				int row;
								
				if( !aob ) {
					missing_option( cmds[i] );
					break;
				}
				if( overlay_cs == NULL ) {
					printf( "Call B_OVERLAY_SUPPORTED_SPACES first\n" );
					break;
				}
				if( ob != NULL ) {
					printf( "This program only allows one overlay buffer to be allocated\n" );
					break;
				}
				
				choice = pick_from_list("Choose overlay colour space:", (char **)overlay_cs_names );
				if( choice < 0 )
					break;
					
				ob = aob( overlay_cs[choice], 320, 200 );
				if( ob == NULL ) {
					printf( "Failed\n" );
					break;
				}

				for( row = 0; row < ob->height; ++row ) {
					
					/*memset( &((char *)ob->buffer)[row * ob->bytes_per_row], 
						row & 1 ? 0xaa : 0x55, ob->bytes_per_row );*/
					uint col;
					char *buf = &((char *)ob->buffer)[row * ob->bytes_per_row];
					
					for( col = 0; col < ob->bytes_per_row / 4; ++col ) {
						buf[col*4] = 255-row;
						buf[col*4+1] = 255-row;
						buf[col*4+2] = 255-row;
						buf[col*4+3] = 0;
					}
				}
			} break;
			case B_RELEASE_OVERLAY_BUFFER: {
				release_overlay_buffer rob = gah(B_RELEASE_OVERLAY_BUFFER, &dm);
				if( !rob ) {
					missing_option( cmds[i] );
					break;
				}
				if( ob == NULL ) {
					printf( "Call B_ALLOCATE_OVERLAY_BUFFER first\n" );
					break;
				}
				rob( ob );
				ob = NULL;
			} break;
			case B_GET_OVERLAY_CONSTRAINTS: {
				get_overlay_constraints ocn = gah(B_GET_OVERLAY_CONSTRAINTS, &dm);
				overlay_constraints oc;
				
				if( !ocn ) {
					missing_option( cmds[i] );
					break;
				}
				if( ob == NULL ) {
					printf( "Call B_ALLOCATE_OVERLAY_BUFFER first\n" );
					break;
				}
				result = ocn( &dm, ob, &oc );
				if (result != B_OK)
					failed_with_reason("B_GET_OVERLAY_CONSTRAINTS", result);
					
				dump_overlay_limits( "view", &oc.view );
				dump_overlay_limits( "window", &oc.window );
				dump_overlay_scale_limits( "h_scale", &oc.h_scale );
				dump_overlay_scale_limits( "v_scale", &oc.v_scale );
			} break;
			case B_ALLOCATE_OVERLAY: {
				allocate_overlay aov = gah( B_ALLOCATE_OVERLAY, &dm );
				if( !aov ) {
					missing_option( cmds[i] );
					break;
				}
				if( ot ) {
					printf( "This program only allows one overlay to be allocated\n" );
					break;
				}
				ot = aov();
				if( ot == NULL ) {
					printf( "Cannot allocate overlay\n" );
					break;
				}
			} break;
			case B_RELEASE_OVERLAY: {
				release_overlay rov = gah( B_RELEASE_OVERLAY, &dm );
				if( !rov ) {
					missing_option( cmds[i] );
					break;
				}
				if( !ot ) {
					printf( "Call B_ALLOCATE_OVERLAY first\n" );
					break;
				}
				result = rov( ot );
				if( result != B_OK )
					failed_with_reason( "B_RELEASE_OVERLAY", result );
					
				ot = NULL;
			} break;
			case B_CONFIGURE_OVERLAY: {
				configure_overlay cov = gah( B_CONFIGURE_OVERLAY, &dm );
				overlay_window ow;
				overlay_view ov;
				if( !cov ) {
					missing_option( cmds[i] );
					break;
				}
				if( !ot ) {
					printf( "Call B_ALLOCATE_OVERLAY first\n" );
					break;
				}
				if( ob == NULL ) {
					printf( "Call B_ALLOCATE_OVERLAY_BUFFER first\n" );
					break;
				}

				ow.h_start = 16;
				ow.v_start = 16;
				ow.width = dm.virtual_width - 32;
				ow.height = dm.virtual_height - 32;
				ow.offset_left = 0;
				ow.offset_top = 0;
				ow.offset_right = 0;
				ow.offset_bottom = 0;
				
				ow.red.mask = 0xff;
				ow.red.value = 0;
				ow.green.mask = 0xff;
				ow.green.value = 0;
				ow.blue.mask = 0xff;
				ow.blue.value = 0;
				ow.alpha.mask = 0xff;
				ow.alpha.value = 0;
				ow.flags = B_OVERLAY_COLOR_KEY;
				
				ov.h_start = 0;
				ov.v_start = 0;
				ov.width = ob->width;
				ov.height = ob->height;
				
				result = cov( ot, ob, &ow, &ov);	
				if( result != B_OK )
					failed_with_reason( "B_RELEASE_OVERLAY", result );
			} break;
				
			default: {
				printf("Ooops: %s not implemented yet.\n", cmds[i]);
			} break;
		}
	}
	/* clean up */
	if (cmds) free(cmds);
	if (mode_list) free(mode_list);
	if( overlay_cs_names ) free( overlay_cs_names );
}

#define T_GRAPHICS_DEVICE_DIR "/dev/graphics"
int main(int argc, char **argv) {
	int fd;
	GetAccelerantHook gah;
	image_id image;

	/* pick a device */
	fd = pick_device(T_GRAPHICS_DEVICE_DIR);
	if (fd < 0) {
		fprintf(stderr, "Can't open device: %s (%s)\n", strerror(fd), strerror(errno));
		return fd;
	}
	/* load the accelerant */
	image = load_accelerant(fd, &gah);
	if (image < 0) goto close_driver;

	exercise_driver(gah);

	/* uninit accelerant */
	{
	uninit_accelerant ua = gah(B_UNINIT_ACCELERANT, NULL);
	if (ua) ua();
	}
	/* unload add-on */
	unload_add_on(image);	
close_driver:
	/* close the driver */
	close(fd);
	return B_OK;
}