--- BasiliskII/src/video.cpp 2002/01/15 14:58:32 1.24 +++ BasiliskII/src/video.cpp 2005/01/30 21:42:13 1.28 @@ -1,7 +1,7 @@ /* * video.cpp - Video/graphics emulation * - * Basilisk II (C) 1997-2002 Christian Bauer + * Basilisk II (C) 1997-2005 Christian Bauer * Portions written by Marc Hellwig * * This program is free software; you can redistribute it and/or modify @@ -41,55 +41,94 @@ #include "debug.h" -// List of supported video modes -vector VideoModes; +// Next available NuBus slot ID +uint8 monitor_desc::next_slot_id = 0x80; -// Description of the main monitor -monitor_desc VideoMonitor; +// Vector of pointers to available monitor descriptions, filled by VideoInit() +vector VideoMonitors; -// Depth code -> Apple mode mapping -uint16 apple_mode_for_depth[6]; -// Local variables (per monitor) -struct { - monitor_desc *desc; // Pointer to description of monitor handled by this instance of the driver - uint8 palette[256 * 3]; // Color palette, 256 entries, RGB - bool luminance_mapping; // Luminance mapping on/off - bool interrupts_enabled; // VBL interrupts on/off - bool dm_present; // We received a GetVideoParameters call, so the Display Manager seems to be present - uint32 gamma_table; // Mac address of gamma table - int alloc_gamma_table_size; // Allocated size of gamma table - uint16 current_mode; // Currently selected depth/resolution - uint32 current_id; - uint16 preferred_mode; // Preferred depth/resolution - uint32 preferred_id; - uint32 slot_param; // Mac address of Slot Manager parameter block -} VidLocal; +/* + * Find palette size for given color depth + */ + +static int palette_size(video_depth depth) +{ + switch (depth) { + case VDEPTH_1BIT: return 2; + case VDEPTH_2BIT: return 4; + case VDEPTH_4BIT: return 16; + case VDEPTH_8BIT: return 256; + case VDEPTH_16BIT: return 32; + case VDEPTH_32BIT: return 256; + default: return 0; + } +} /* - * Initialize apple_mode_for_depth[] array from VideoModes list + * Find pointer to monitor_desc for given slot ID (or NULL if not found) */ -void video_init_depth_list(void) +static monitor_desc *find_monitor(uint8 id) { + vector::const_iterator i, end = VideoMonitors.end(); + for (i = VideoMonitors.begin(); i != end; ++i) { + if ((*i)->get_slot_id() == id) + return *i; + } + return NULL; +} + + +/* + * monitor_desc constructor + */ + +monitor_desc::monitor_desc(const vector &available_modes, video_depth default_depth, uint32 default_id) : modes(available_modes) +{ + // Assign the next slot ID on construction + slot_id = next_slot_id++; + + // Initialize Apple mode list uint16 mode = 0x80; for (int depth = VDEPTH_1BIT; depth <= VDEPTH_32BIT; depth++) { - if (video_has_depth(video_depth(depth))) + if (has_depth(video_depth(depth))) apple_mode_for_depth[depth] = mode++; else apple_mode_for_depth[depth] = 0; } + + // Set default mode + current_mode = find_mode(depth_to_apple_mode(default_depth), default_id); } /* - * Check whether a mode with the specified depth exists + * Get bytes-per-row value for specified resolution/depth + * (if the mode isn't supported, make a good guess) */ -bool video_has_depth(video_depth depth) +uint32 monitor_desc::get_bytes_per_row(video_depth depth, uint32 id) const { - vector::const_iterator i = VideoModes.begin(), end = VideoModes.end(); + vector::const_iterator i, end = modes.end(); + for (i = modes.begin(); i != end; ++i) { + if (i->depth == depth && i->resolution_id == id) + return i->bytes_per_row; + } + uint32 x, y; + get_size_of_resolution(id, x, y); + return TrivialBytesPerRow(x, depth); +} + + +/* + * Check whether a mode with the specified depth exists on this display + */ + +bool monitor_desc::has_depth(video_depth depth) const +{ + vector::const_iterator i = modes.begin(), end = modes.end(); while (i != end) { if (i->depth == depth) return true; @@ -100,13 +139,13 @@ bool video_has_depth(video_depth depth) /* - * Check whether specified resolution ID is one of the supported resolutions + * Check whether the specified resolution ID is one of the supported resolutions */ -static bool has_resolution(uint32 id) +bool monitor_desc::has_resolution(uint32 id) const { - vector::const_iterator i, end = VideoModes.end(); - for (i = VideoModes.begin(); i != end; ++i) { + vector::const_iterator i, end = modes.end(); + for (i = modes.begin(); i != end; ++i) { if (i->resolution_id == id) return true; } @@ -115,14 +154,14 @@ static bool has_resolution(uint32 id) /* - * Find specified mode (depth/resolution) (or VideoModes.end() if not found) + * Find specified mode (depth/resolution) (or invalid_mode() if not found) */ -static vector::const_iterator find_mode(uint16 mode, uint32 id) +vector::const_iterator monitor_desc::find_mode(uint16 apple_mode, uint32 id) const { - vector::const_iterator i, end = VideoModes.end(); - for (i = VideoModes.begin(); i != end; ++i) { - if (i->resolution_id == id && DepthToAppleMode(i->depth) == mode) + vector::const_iterator i, end = modes.end(); + for (i = modes.begin(); i != end; ++i) { + if (i->resolution_id == id && depth_to_apple_mode(i->depth) == apple_mode) return i; } return i; @@ -133,11 +172,11 @@ static vector::const_iterato * Find maximum supported depth for given resolution ID */ -static video_depth max_depth_of_resolution(uint32 id) +video_depth monitor_desc::max_depth_of_resolution(uint32 id) const { video_depth m = VDEPTH_1BIT; - vector::const_iterator i, end = VideoModes.end(); - for (i = VideoModes.begin(); i != end; ++i) { + vector::const_iterator i, end = modes.end(); + for (i = modes.begin(); i != end; ++i) { if (i->depth > m) m = i->depth; } @@ -149,10 +188,10 @@ static video_depth max_depth_of_resoluti * Get X/Y size of specified resolution */ -static void get_size_of_resolution(uint32 id, uint32 &x, uint32 &y) +void monitor_desc::get_size_of_resolution(uint32 id, uint32 &x, uint32 &y) const { - vector::const_iterator i, end = VideoModes.end(); - for (i = VideoModes.begin(); i != end; ++i) { + vector::const_iterator i, end = modes.end(); + for (i = modes.begin(); i != end; ++i) { if (i->resolution_id == id) { x = i->x; y = i->y; @@ -164,52 +203,17 @@ static void get_size_of_resolution(uint3 /* - * Get bytes-per-row value for specified resolution/depth - */ - -uint32 video_bytes_per_row(video_depth depth, uint32 id) -{ - vector::const_iterator i, end = VideoModes.end(); - for (i = VideoModes.begin(); i != end; ++i) { - if (i->depth == depth && i->resolution_id == id) - return i->bytes_per_row; - } - uint32 x, y; - get_size_of_resolution(id, x, y); - return TrivialBytesPerRow(x, depth); -} - - -/* - * Find palette size for given color depth - */ - -static int palette_size(video_depth depth) -{ - switch (depth) { - case VDEPTH_1BIT: return 2; - case VDEPTH_2BIT: return 4; - case VDEPTH_4BIT: return 16; - case VDEPTH_8BIT: return 256; - case VDEPTH_16BIT: return 32; - case VDEPTH_32BIT: return 256; - default: return 0; - } -} - - -/* * Set palette to 50% gray */ -static void set_gray_palette(void) +void monitor_desc::set_gray_palette(void) { for (int i=0; i<256; i++) { - VidLocal.palette[i * 3 + 0] = 127; - VidLocal.palette[i * 3 + 1] = 127; - VidLocal.palette[i * 3 + 2] = 127; + palette[i * 3 + 0] = 127; + palette[i * 3 + 1] = 127; + palette[i * 3 + 2] = 127; } - video_set_palette(VidLocal.palette, 256); + set_palette(palette, 256); } @@ -217,14 +221,14 @@ static void set_gray_palette(void) * Load gamma-corrected black-to-white ramp to palette for direct-color mode */ -static void load_ramp_palette(void) +void monitor_desc::load_ramp_palette(void) { // Find tables for gamma correction uint8 *red_gamma = NULL, *green_gamma = NULL, *blue_gamma = NULL; bool have_gamma = false; int data_width = 0; - if (VidLocal.gamma_table) { - uint32 table = VidLocal.gamma_table; + if (gamma_table) { + uint32 table = gamma_table; red_gamma = Mac2HostAddr(table + gFormulaData + ReadMacInt16(table + gFormulaSize)); int chan_cnt = ReadMacInt16(table + gChanCnt); if (chan_cnt == 1) @@ -238,8 +242,8 @@ static void load_ramp_palette(void) have_gamma = true; } - int num = (VidLocal.desc->mode.depth == VDEPTH_16BIT ? 32 : 256); - uint8 *p = VidLocal.palette; + int num = (current_mode->depth == VDEPTH_16BIT ? 32 : 256); + uint8 *p = palette; for (int i=0; i VidLocal.alloc_gamma_table_size) { - if (VidLocal.gamma_table) { - r.a[0] = VidLocal.gamma_table; + if (size > alloc_gamma_table_size) { + if (gamma_table) { + r.a[0] = gamma_table; Execute68kTrap(0xa01f, &r); // DisposePtr() - VidLocal.gamma_table = 0; - VidLocal.alloc_gamma_table_size = 0; + gamma_table = 0; + alloc_gamma_table_size = 0; } r.d[0] = size; Execute68kTrap(0xa71e, &r); // NewPtrSysClear() if (r.a[0] == 0) return false; - VidLocal.gamma_table = r.a[0]; - VidLocal.alloc_gamma_table_size = size; + gamma_table = r.a[0]; + alloc_gamma_table_size = size; } return true; } @@ -286,25 +290,24 @@ static bool allocate_gamma_table(int siz * Set gamma table (0 = build linear ramp) */ -static bool set_gamma_table(uint32 user_table) +bool monitor_desc::set_gamma_table(uint32 user_table) { if (user_table == 0) { // Build linear ramp, 256 entries // Allocate new table, if necessary if (!allocate_gamma_table(SIZEOF_GammaTbl + 256)) return memFullErr; - uint32 table = VidLocal.gamma_table; // Initialize header - WriteMacInt16(table + gVersion, 0); - WriteMacInt16(table + gType, 0); - WriteMacInt16(table + gFormulaSize, 0); - WriteMacInt16(table + gChanCnt, 1); - WriteMacInt16(table + gDataCnt, 256); - WriteMacInt16(table + gDataWidth, 8); + WriteMacInt16(gamma_table + gVersion, 0); + WriteMacInt16(gamma_table + gType, 0); + WriteMacInt16(gamma_table + gFormulaSize, 0); + WriteMacInt16(gamma_table + gChanCnt, 1); + WriteMacInt16(gamma_table + gDataCnt, 256); + WriteMacInt16(gamma_table + gDataWidth, 8); // Build ramp - uint32 p = table + gFormulaData; + uint32 p = gamma_table + gFormulaData; for (int i=0; i<256; i++) WriteMacInt8(p + i, i); @@ -329,13 +332,12 @@ static bool set_gamma_table(uint32 user_ int size = SIZEOF_GammaTbl + ReadMacInt16(user_table + gFormulaSize) + chan_cnt * data_cnt; if (!allocate_gamma_table(size)) return memFullErr; - uint32 table = VidLocal.gamma_table; // Copy table - Mac2Mac_memcpy(table, user_table, size); + Mac2Mac_memcpy(gamma_table, user_table, size); } - if (IsDirectMode(VidLocal.desc->mode)) + if (IsDirectMode(*current_mode)) load_ramp_palette(); return true; @@ -346,49 +348,49 @@ static bool set_gamma_table(uint32 user_ * Switch video mode */ -static void switch_mode(const video_mode &mode, uint32 param, uint32 dce) +void monitor_desc::switch_mode(vector::const_iterator it, uint32 param, uint32 dce) { + const video_mode &mode = *it; + // Switch mode set_gray_palette(); - video_switch_to_mode(mode); - - // Update VidLocal - VidLocal.current_mode = DepthToAppleMode(mode.depth); - VidLocal.current_id = mode.resolution_id; + current_mode = it; + switch_to_current_mode(); - uint32 frame_base = VidLocal.desc->mac_frame_base; + // Update variables + current_apple_mode = depth_to_apple_mode(mode.depth); + current_id = mode.resolution_id; M68kRegisters r; - uint32 sp = VidLocal.slot_param; - r.a[0] = sp; + r.a[0] = slot_param; // Find functional sResource for this display - WriteMacInt8(sp + spSlot, ReadMacInt8(dce + dCtlSlot)); - WriteMacInt8(sp + spID, ReadMacInt8(dce + dCtlSlotId)); - WriteMacInt8(sp + spExtDev, 0); + WriteMacInt8(slot_param + spSlot, ReadMacInt8(dce + dCtlSlot)); + WriteMacInt8(slot_param + spID, ReadMacInt8(dce + dCtlSlotId)); + WriteMacInt8(slot_param + spExtDev, 0); r.d[0] = 0x0016; Execute68kTrap(0xa06e, &r); // SRsrcInfo() - uint32 rsrc = ReadMacInt32(sp + spPointer); + uint32 rsrc = ReadMacInt32(slot_param + spPointer); // Patch minorBase (otherwise rebooting won't work) - WriteMacInt8(sp + spID, 0x0a); // minorBase + WriteMacInt8(slot_param + spID, 0x0a); // minorBase r.d[0] = 0x0006; Execute68kTrap(0xa06e, &r); // SFindStruct() - uint32 minor_base = ReadMacInt32(sp + spPointer) - ROMBaseMac; - ROMBaseHost[minor_base + 0] = frame_base >> 24; - ROMBaseHost[minor_base + 1] = frame_base >> 16; - ROMBaseHost[minor_base + 2] = frame_base >> 8; - ROMBaseHost[minor_base + 3] = frame_base; + uint32 minor_base = ReadMacInt32(slot_param + spPointer) - ROMBaseMac; + ROMBaseHost[minor_base + 0] = mac_frame_base >> 24; + ROMBaseHost[minor_base + 1] = mac_frame_base >> 16; + ROMBaseHost[minor_base + 2] = mac_frame_base >> 8; + ROMBaseHost[minor_base + 3] = mac_frame_base; // Patch video mode parameter table - WriteMacInt32(sp + spPointer, rsrc); - WriteMacInt8(sp + spID, DepthToAppleMode(mode.depth)); + WriteMacInt32(slot_param + spPointer, rsrc); + WriteMacInt8(slot_param + spID, depth_to_apple_mode(mode.depth)); r.d[0] = 0x0006; Execute68kTrap(0xa06e, &r); // SFindStruct() - WriteMacInt8(sp + spID, 0x01); + WriteMacInt8(slot_param + spID, 0x01); r.d[0] = 0x0006; Execute68kTrap(0xa06e, &r); // SFindStruct() - uint32 p = ReadMacInt32(sp + spPointer) - ROMBaseMac; + uint32 p = ReadMacInt32(slot_param + spPointer) - ROMBaseMac; ROMBaseHost[p + 8] = mode.bytes_per_row >> 8; ROMBaseHost[p + 9] = mode.bytes_per_row; ROMBaseHost[p + 14] = mode.y >> 8; @@ -400,23 +402,32 @@ static void switch_mode(const video_mode ChecksumSlotROM(); // Update sResource - WriteMacInt8(sp + spID, ReadMacInt8(dce + dCtlSlotId)); + WriteMacInt8(slot_param + spID, ReadMacInt8(dce + dCtlSlotId)); r.d[0] = 0x002b; Execute68kTrap(0xa06e, &r); // SUpdateSRT() // Update frame buffer base in DCE and param block - WriteMacInt32(dce + dCtlDevBase, frame_base); - WriteMacInt32(param + csBaseAddr, frame_base); + WriteMacInt32(dce + dCtlDevBase, mac_frame_base); + WriteMacInt32(param + csBaseAddr, mac_frame_base); // Patch frame buffer base address for MacOS versions <7.6 - if (!VidLocal.dm_present) { // Only do this when no Display Manager seems to be present; otherwise, the screen will not get redrawn - WriteMacInt32(0x824, frame_base); // ScrnBase - WriteMacInt32(0x898, frame_base); // CrsrBase + if (!dm_present) { // Only do this when no Display Manager seems to be present; otherwise, the screen will not get redrawn + D(bug("No Display Manager, patching frame buffer base\n")); + WriteMacInt32(0x824, mac_frame_base); // ScrnBase + WriteMacInt32(0x898, mac_frame_base); // CrsrBase uint32 gdev = ReadMacInt32(0x8a4); // MainDevice - gdev = ReadMacInt32(gdev); - uint32 pmap = ReadMacInt32(gdev + 0x16); // gdPMap - pmap = ReadMacInt32(pmap); - WriteMacInt32(pmap, frame_base); // baseAddr + D(bug("MainDevice handle at %08lx\n", gdev)); + if (gdev != 0 && gdev != 0xffffffff) { + gdev = ReadMacInt32(gdev); + D(bug(" pointer at %08lx\n", gdev)); + uint32 pmap = ReadMacInt32(gdev + 0x16); // gdPMap + D(bug(" PixMap handle at %08lx\n", pmap)); + pmap = ReadMacInt32(pmap); + D(bug(" pointer at %08lx\n", pmap)); + WriteMacInt32(pmap, mac_frame_base); // baseAddr + } + gdev = ReadMacInt32(0xcc8); // TheGDevice + D(bug("TheGDevice handle at %08lx\n", gdev)); } } @@ -425,23 +436,18 @@ static void switch_mode(const video_mode * Driver Open() routine */ -int16 VideoDriverOpen(uint32 pb, uint32 dce) +int16 monitor_desc::driver_open(void) { - D(bug("VideoDriverOpen\n")); - // This shouldn't happen unless the platform-specific video code is broken - if (VideoModes.empty()) + if (modes.empty()) fprintf(stderr, "No valid video modes found (broken video driver?)\n"); // Init local variables - VidLocal.desc = &VideoMonitor; - VidLocal.luminance_mapping = false; - VidLocal.interrupts_enabled = false; - VidLocal.current_mode = DepthToAppleMode(VidLocal.desc->mode.depth); - VidLocal.current_id = VidLocal.desc->mode.resolution_id; - VidLocal.preferred_mode = VidLocal.current_mode; - VidLocal.preferred_id = VidLocal.current_id; - VidLocal.dm_present = false; + luminance_mapping = false; + interrupts_enabled = false; + current_apple_mode = preferred_apple_mode = depth_to_apple_mode(current_mode->depth); + current_id = preferred_id = current_mode->resolution_id; + dm_present = false; // Allocate Slot Manager parameter block in Mac RAM M68kRegisters r; @@ -449,12 +455,12 @@ int16 VideoDriverOpen(uint32 pb, uint32 Execute68kTrap(0xa71e, &r); // NewPtrSysClear() if (r.a[0] == 0) return memFullErr; - VidLocal.slot_param = r.a[0]; - D(bug("SPBlock at %08x\n", VidLocal.slot_param)); + slot_param = r.a[0]; + D(bug("SPBlock at %08x\n", slot_param)); // Find and set default gamma table - VidLocal.gamma_table = 0; - VidLocal.alloc_gamma_table_size = 0; + gamma_table = 0; + alloc_gamma_table_size = 0; set_gamma_table(0); // Init color palette (solid gray) @@ -462,16 +468,25 @@ int16 VideoDriverOpen(uint32 pb, uint32 return noErr; } +int16 VideoDriverOpen(uint32 pb, uint32 dce) +{ + uint8 slot_id = ReadMacInt8(dce + dCtlSlotId); + D(bug("VideoDriverOpen slot %02x\n", slot_id)); + + monitor_desc *m = find_monitor(slot_id); + if (m) + return m->driver_open(); + else + return nsDrvErr; +} + /* * Driver Control() routine */ -int16 VideoDriverControl(uint32 pb, uint32 dce) +int16 monitor_desc::driver_control(uint16 code, uint32 param, uint32 dce) { - uint16 code = ReadMacInt16(pb + csCode); - uint32 param = ReadMacInt32(pb + csParam); - D(bug("VideoDriverControl %d\n", code)); switch (code) { case cscSetMode: { // Set color depth @@ -479,25 +494,25 @@ int16 VideoDriverControl(uint32 pb, uint D(bug(" SetMode %04x\n", mode)); // Set old base address in case the switch fails - WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + WriteMacInt32(param + csBaseAddr, mac_frame_base); if (ReadMacInt16(param + csPage)) return paramErr; - if (mode != VidLocal.current_mode) { - vector::const_iterator i = find_mode(mode, VidLocal.current_id); - if (i == VideoModes.end()) + if (mode != current_apple_mode) { + vector::const_iterator i = find_mode(mode, current_id); + if (i == invalid_mode()) return paramErr; - switch_mode(*i, param, dce); + switch_mode(i, param, dce); } - D(bug(" base %08x\n", VidLocal.desc->mac_frame_base)); + D(bug(" base %08x\n", mac_frame_base)); return noErr; } case cscSetEntries: // Set palette case cscDirectSetEntries: { D(bug(" (Direct)SetEntries table %08x, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart))); - bool is_direct = IsDirectMode(VidLocal.desc->mode); + bool is_direct = IsDirectMode(*current_mode); if (code == cscSetEntries && is_direct) return controlErr; if (code == cscDirectSetEntries && !is_direct) @@ -514,29 +529,28 @@ int16 VideoDriverControl(uint32 pb, uint uint8 *red_gamma = NULL, *green_gamma = NULL, *blue_gamma = NULL; bool have_gamma = false; int data_width = 0; - if (VidLocal.gamma_table) { - uint32 table = VidLocal.gamma_table; - red_gamma = Mac2HostAddr(table + gFormulaData + ReadMacInt16(table + gFormulaSize)); - int chan_cnt = ReadMacInt16(table + gChanCnt); + if (gamma_table) { + red_gamma = Mac2HostAddr(gamma_table + gFormulaData + ReadMacInt16(gamma_table + gFormulaSize)); + int chan_cnt = ReadMacInt16(gamma_table + gChanCnt); if (chan_cnt == 1) green_gamma = blue_gamma = red_gamma; else { - int ofs = ReadMacInt16(table + gDataCnt); + int ofs = ReadMacInt16(gamma_table + gDataCnt); green_gamma = red_gamma + ofs; blue_gamma = green_gamma + ofs; } - data_width = ReadMacInt16(table + gDataWidth); + data_width = ReadMacInt16(gamma_table + gDataWidth); have_gamma = true; } // Convert palette if (start == 0xffff) { // Indexed for (uint32 i=0; i<=count; i++) { - d_pal = VidLocal.palette + (ReadMacInt16(s_pal) & 0xff) * 3; + d_pal = palette + (ReadMacInt16(s_pal) & 0xff) * 3; uint8 red = (uint16)ReadMacInt16(s_pal + 2) >> 8; uint8 green = (uint16)ReadMacInt16(s_pal + 4) >> 8; uint8 blue = (uint16)ReadMacInt16(s_pal + 6) >> 8; - if (VidLocal.luminance_mapping && !is_direct) + if (luminance_mapping && !is_direct) red = green = blue = (red * 0x4ccc + green * 0x970a + blue * 0x1c29) >> 16; if (have_gamma) { red = red_gamma[red >> (8 - data_width)]; @@ -551,12 +565,12 @@ int16 VideoDriverControl(uint32 pb, uint } else { // Sequential if (start + count > 255) return paramErr; - d_pal = VidLocal.palette + start * 3; + d_pal = palette + start * 3; for (uint32 i=0; i<=count; i++) { uint8 red = (uint16)ReadMacInt16(s_pal + 2) >> 8; uint8 green = (uint16)ReadMacInt16(s_pal + 4) >> 8; uint8 blue = (uint16)ReadMacInt16(s_pal + 6) >> 8; - if (VidLocal.luminance_mapping && !is_direct) + if (luminance_mapping && !is_direct) red = green = blue = (red * 0x4ccc + green * 0x970a + blue * 0x1c29) >> 16; if (have_gamma) { red = red_gamma[red >> (8 - data_width)]; @@ -569,7 +583,7 @@ int16 VideoDriverControl(uint32 pb, uint s_pal += 8; } } - video_set_palette(VidLocal.palette, palette_size(VidLocal.desc->mode.depth)); + set_palette(palette, palette_size(current_mode->depth)); return noErr; } @@ -592,20 +606,20 @@ int16 VideoDriverControl(uint32 pb, uint 0xffff0000, // 16 bpp 0xffffffff // 32 bpp }; - uint32 frame_base = VidLocal.desc->mac_frame_base; - uint32 pat = pattern[VidLocal.desc->mode.depth]; - bool invert = (VidLocal.desc->mode.depth == VDEPTH_32BIT); - for (uint32 y=0; ymode.y; y++) { - for (uint32 x=0; xmode.bytes_per_row; x+=4) { - WriteMacInt32(frame_base + x, pat); + uint32 p = mac_frame_base; + uint32 pat = pattern[current_mode->depth]; + bool invert = (current_mode->depth == VDEPTH_32BIT); + for (uint32 y=0; yy; y++) { + for (uint32 x=0; xbytes_per_row; x+=4) { + WriteMacInt32(p + x, pat); if (invert) pat = ~pat; } - frame_base += VidLocal.desc->mode.bytes_per_row; + p += current_mode->bytes_per_row; pat = ~pat; } - if (IsDirectMode(VidLocal.desc->mode)) + if (IsDirectMode(*current_mode)) load_ramp_palette(); return noErr; @@ -613,18 +627,18 @@ int16 VideoDriverControl(uint32 pb, uint case cscSetGray: // Enable/disable luminance mapping D(bug(" SetGray %02x\n", ReadMacInt8(param + csMode))); - VidLocal.luminance_mapping = ReadMacInt8(param + csMode); + luminance_mapping = ReadMacInt8(param + csMode); return noErr; case cscSetInterrupt: // Enable/disable VBL D(bug(" SetInterrupt %02x\n", ReadMacInt8(param + csMode))); - VidLocal.interrupts_enabled = (ReadMacInt8(param + csMode) == 0); + interrupts_enabled = (ReadMacInt8(param + csMode) == 0); return noErr; case cscSetDefaultMode: { // Set default color depth uint16 mode = ReadMacInt8(param + csMode); D(bug(" SetDefaultMode %02x\n", mode)); - VidLocal.preferred_mode = mode; + preferred_apple_mode = mode; return noErr; } @@ -634,18 +648,18 @@ int16 VideoDriverControl(uint32 pb, uint D(bug(" SwitchMode %04x, %08x\n", mode, id)); // Set old base address in case the switch fails - WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + WriteMacInt32(param + csBaseAddr, mac_frame_base); if (ReadMacInt16(param + csPage)) return paramErr; - if (mode != VidLocal.current_mode || id != VidLocal.current_id) { + if (mode != current_apple_mode || id != current_id) { vector::const_iterator i = find_mode(mode, id); - if (i == VideoModes.end()) + if (i == invalid_mode()) return paramErr; - switch_mode(*i, param, dce); + switch_mode(i, param, dce); } - D(bug(" base %08x\n", VidLocal.desc->mac_frame_base)); + D(bug(" base %08x\n", mac_frame_base)); return noErr; } @@ -653,8 +667,8 @@ int16 VideoDriverControl(uint32 pb, uint uint16 mode = ReadMacInt16(param + csMode); uint32 id = ReadMacInt32(param + csData); D(bug(" SavePreferredConfiguration %04x, %08x\n", mode, id)); - VidLocal.preferred_mode = mode; - VidLocal.preferred_id = id; + preferred_apple_mode = mode; + preferred_id = id; return noErr; } @@ -664,23 +678,34 @@ int16 VideoDriverControl(uint32 pb, uint } } +int16 VideoDriverControl(uint32 pb, uint32 dce) +{ + uint8 slot_id = ReadMacInt8(dce + dCtlSlotId); + uint16 code = ReadMacInt16(pb + csCode); + uint32 param = ReadMacInt32(pb + csParam); + D(bug("VideoDriverControl slot %02x, code %d\n", slot_id, code)); + + monitor_desc *m = find_monitor(slot_id); + if (m) + return m->driver_control(code, param, dce); + else + return nsDrvErr; +} + /* * Driver Status() routine */ -int16 VideoDriverStatus(uint32 pb, uint32 dce) +int16 monitor_desc::driver_status(uint16 code, uint32 param) { - uint16 code = ReadMacInt16(pb + csCode); - uint32 param = ReadMacInt32(pb + csParam); - D(bug("VideoDriverStatus %d\n", code)); switch (code) { case cscGetMode: // Get current color depth - D(bug(" GetMode -> %04x, base %08x\n", VidLocal.current_mode, VidLocal.desc->mac_frame_base)); - WriteMacInt16(param + csMode, VidLocal.current_mode); + D(bug(" GetMode -> %04x, base %08x\n", current_apple_mode, mac_frame_base)); + WriteMacInt16(param + csMode, current_apple_mode); WriteMacInt16(param + csPage, 0); - WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + WriteMacInt32(param + csBaseAddr, mac_frame_base); return noErr; case cscGetEntries: { // Read palette @@ -695,7 +720,7 @@ int16 VideoDriverStatus(uint32 pb, uint3 if (start == 0xffff) { // Indexed for (uint32 i=0; i<=count; i++) { - s_pal = VidLocal.palette + (ReadMacInt16(d_pal) & 0xff) * 3; + s_pal = palette + (ReadMacInt16(d_pal) & 0xff) * 3; uint8 red = *s_pal++; uint8 green = *s_pal++; uint8 blue = *s_pal++; @@ -707,7 +732,7 @@ int16 VideoDriverStatus(uint32 pb, uint3 } else { // Sequential if (start + count > 255) return paramErr; - s_pal = VidLocal.palette + start * 3; + s_pal = palette + start * 3; for (uint32 i=0; i<=count; i++) { uint8 red = *s_pal++; uint8 green = *s_pal++; @@ -727,39 +752,39 @@ int16 VideoDriverStatus(uint32 pb, uint3 return noErr; case cscGetBaseAddress: // Get page base address - D(bug(" GetBaseAddress -> %08x\n", VidLocal.desc->mac_frame_base)); - WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + D(bug(" GetBaseAddress -> %08x\n", mac_frame_base)); + WriteMacInt32(param + csBaseAddr, mac_frame_base); if (ReadMacInt16(param + csPage)) return paramErr; else return noErr; case cscGetGray: // Get luminance mapping flag - D(bug(" GetGray -> %d\n", VidLocal.luminance_mapping)); - WriteMacInt8(param, VidLocal.luminance_mapping ? 1 : 0); + D(bug(" GetGray -> %d\n", luminance_mapping)); + WriteMacInt8(param, luminance_mapping ? 1 : 0); return noErr; case cscGetInterrupt: // Get interrupt disable flag - D(bug(" GetInterrupt -> %d\n", VidLocal.interrupts_enabled)); - WriteMacInt8(param, VidLocal.interrupts_enabled ? 0 : 1); + D(bug(" GetInterrupt -> %d\n", interrupts_enabled)); + WriteMacInt8(param, interrupts_enabled ? 0 : 1); return noErr; case cscGetGamma: - D(bug(" GetGamma -> %08x\n", VidLocal.gamma_table)); - WriteMacInt32(param + csGTable, VidLocal.gamma_table); + D(bug(" GetGamma -> %08x\n", gamma_table)); + WriteMacInt32(param + csGTable, gamma_table); return noErr; case cscGetDefaultMode: // Get default color depth - D(bug(" GetDefaultMode -> %02x\n", VidLocal.preferred_mode)); - WriteMacInt8(param + csMode, VidLocal.preferred_mode); + D(bug(" GetDefaultMode -> %02x\n", preferred_apple_mode)); + WriteMacInt8(param + csMode, preferred_apple_mode); return noErr; case cscGetCurrentMode: // Get current video mode (depth and resolution) - D(bug(" GetCurMode -> %04x/%08x, base %08x\n", VidLocal.current_mode, VidLocal.current_id, VidLocal.desc->mac_frame_base)); - WriteMacInt16(param + csMode, VidLocal.current_mode); - WriteMacInt32(param + csData, VidLocal.current_id); + D(bug(" GetCurMode -> %04x/%08x, base %08x\n", current_apple_mode, current_id, mac_frame_base)); + WriteMacInt16(param + csMode, current_apple_mode); + WriteMacInt32(param + csData, current_id); WriteMacInt16(param + csPage, 0); - WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + WriteMacInt32(param + csBaseAddr, mac_frame_base); return noErr; case cscGetConnection: // Get monitor information @@ -780,21 +805,21 @@ int16 VideoDriverStatus(uint32 pb, uint3 WriteMacInt32(param + csTimingFormat, FOURCC('d', 'e', 'c', 'l')); WriteMacInt32(param + csTimingData, 0); // unknown uint32 flags = 0xb; // mode valid, safe and shown in Monitors panel - if (id == VidLocal.preferred_id) + if (id == preferred_id) flags |= 4; // default mode WriteMacInt32(param + csTimingFlags, flags); return noErr; } case cscGetModeBaseAddress: // Get frame buffer base address - D(bug(" GetModeBaseAddress -> base %08x\n", VidLocal.desc->mac_frame_base)); - WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + D(bug(" GetModeBaseAddress -> base %08x\n", mac_frame_base)); + WriteMacInt32(param + csBaseAddr, mac_frame_base); return noErr; case cscGetPreferredConfiguration: // Get default video mode (depth and resolution) - D(bug(" GetPreferredConfiguration -> %04x/%08x\n", VidLocal.preferred_mode, VidLocal.preferred_id)); - WriteMacInt16(param + csMode, VidLocal.preferred_mode); - WriteMacInt32(param + csData, VidLocal.preferred_id); + D(bug(" GetPreferredConfiguration -> %04x/%08x\n", preferred_apple_mode, preferred_id)); + WriteMacInt16(param + csMode, preferred_apple_mode); + WriteMacInt32(param + csData, preferred_id); return noErr; case cscGetNextResolution: { // Called iteratively to obtain a list of all supported resolutions @@ -804,7 +829,7 @@ int16 VideoDriverStatus(uint32 pb, uint3 switch (id) { case 0: // Return current resolution - id = VidLocal.current_id; + id = current_id; break; case 0xfffffffe: @@ -834,7 +859,7 @@ int16 VideoDriverStatus(uint32 pb, uint3 WriteMacInt32(param + csHorizontalPixels, x); WriteMacInt32(param + csVerticalLines, y); WriteMacInt32(param + csRefreshRate, 75 << 16); - WriteMacInt16(param + csMaxDepthMode, DepthToAppleMode(max_depth_of_resolution(id))); + WriteMacInt16(param + csMaxDepthMode, depth_to_apple_mode(max_depth_of_resolution(id))); WriteMacInt32(param + csResolutionFlags, 0); return noErr; } @@ -843,11 +868,12 @@ int16 VideoDriverStatus(uint32 pb, uint3 uint32 id = ReadMacInt32(param + csDisplayModeID); uint16 mode = ReadMacInt16(param + csDepthMode); D(bug(" GetVideoParameters %04x/%08x\n", mode, id)); - VidLocal.dm_present = true; // Display Manager seems to be present + dm_present = true; // Display Manager seems to be present + D(bug(" Display Manager detected\n")); - vector::const_iterator i, end = VideoModes.end(); - for (i = VideoModes.begin(); i != end; ++i) { - if (DepthToAppleMode(i->depth) == mode && i->resolution_id == id) { + vector::const_iterator i, end = modes.end(); + for (i = modes.begin(); i != end; ++i) { + if (depth_to_apple_mode(i->depth) == mode && i->resolution_id == id) { uint32 vp = ReadMacInt32(param + csVPBlockPtr); WriteMacInt32(vp + vpBaseOffset, 0); WriteMacInt16(vp + vpRowBytes, i->bytes_per_row); @@ -912,3 +938,17 @@ int16 VideoDriverStatus(uint32 pb, uint3 return statusErr; } } + +int16 VideoDriverStatus(uint32 pb, uint32 dce) +{ + uint8 slot_id = ReadMacInt8(dce + dCtlSlotId); + uint16 code = ReadMacInt16(pb + csCode); + uint32 param = ReadMacInt32(pb + csParam); + D(bug("VideoDriverStatus slot %02x, code %d\n", slot_id, code)); + + monitor_desc *m = find_monitor(slot_id); + if (m) + return m->driver_status(code, param); + else + return nsDrvErr; +}