--- BasiliskII/src/video.cpp 2000/08/22 12:44:29 1.6 +++ BasiliskII/src/video.cpp 2001/06/27 20:05:23 1.10 @@ -1,7 +1,7 @@ /* * video.cpp - Video/graphics emulation * - * Basilisk II (C) 1997-2000 Christian Bauer + * Basilisk II (C) 1997-2001 Christian Bauer * Portions (C) 1997-1999 Marc Hellwig * * This program is free software; you can redistribute it and/or modify @@ -34,23 +34,97 @@ #include "video.h" #include "video_defs.h" -#define DEBUG 0 +#define DEBUG 1 #include "debug.h" +// List of supported video modes +vector VideoModes; + // Description of the main monitor -video_desc VideoMonitor; +monitor_desc VideoMonitor; // Local variables (per monitor) struct { - video_desc *desc; // Pointer to monitor description + 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 + uint16 current_mode; // Currently selected depth/resolution + uint32 current_id; + uint16 preferred_mode; // Preferred depth/resolution + uint32 preferred_id; } VidLocal; /* + * Check whether specified resolution ID is one of the supported resolutions + */ + +static bool has_resolution(uint32 id) +{ + std::vector::const_iterator i = VideoModes.begin(), end = VideoModes.end(); + while (i != end) { + if (i->resolution_id == id) + return true; + ++i; + } + return false; +} + + +/* + * Find specified mode (depth/resolution) (or VideoModes.end() if not found) + */ + +static std::vector::const_iterator find_mode(uint16 mode, uint32 id) +{ + std::vector::const_iterator i = VideoModes.begin(), end = VideoModes.end(); + while (i != end) { + if (i->resolution_id == id && DepthToAppleMode(i->depth) == mode) + return i; + ++i; + } + return i; +} + + +/* + * Find maximum supported depth for given resolution ID + */ + +static video_depth max_depth_of_resolution(uint32 id) +{ + video_depth m = VDEPTH_1BIT; + vector::const_iterator i = VideoModes.begin(), end = VideoModes.end(); + while (i != end) { + if (i->depth > m) + m = i->depth; + ++i; + } + return m; +} + + +/* + * Get X/Y size of specified resolution + */ + +static void get_size_of_resolution(uint32 id, uint32 &x, uint32 &y) +{ + vector::const_iterator i = VideoModes.begin(), end = VideoModes.end(); + while (i != end) { + if (i->resolution_id == id) { + x = i->x; + y = i->y; + return; + } + ++i; + } +} + + +/* * Driver Open() routine */ @@ -58,10 +132,18 @@ int16 VideoDriverOpen(uint32 pb, uint32 { D(bug("VideoDriverOpen\n")); + // This shouldn't happen unless the platform-specific video code is broken + if (VideoModes.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; // Init color palette (solid gray) if (!IsDirectMode(VidLocal.desc->mode)) { @@ -87,10 +169,22 @@ int16 VideoDriverControl(uint32 pb, uint D(bug("VideoDriverControl %d\n", code)); switch (code) { - case cscSetMode: // Set color depth - D(bug(" SetMode %04x\n", ReadMacInt16(param + csMode))); + case cscSetMode: { // Set color depth + uint16 mode = ReadMacInt16(param + csMode); + D(bug(" SetMode %04x\n", mode)); + + if (mode != VidLocal.current_mode) { + std::vector::const_iterator i = find_mode(mode, VidLocal.current_id); + if (i == VideoModes.end()) { + WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + return paramErr; + } + video_switch_to_mode(*i); + VidLocal.current_mode = mode; + } WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); return noErr; + } case cscSetEntries: { // Set palette D(bug(" SetEntries table %08lx, count %d, start %d\n", ReadMacInt32(param + csTable), ReadMacInt16(param + csCount), ReadMacInt16(param + csStart))); @@ -136,6 +230,7 @@ int16 VideoDriverControl(uint32 pb, uint case cscSetGamma: // Set gamma table D(bug(" SetGamma\n")); + //!! return noErr; case cscGrayPage: { // Fill page with dithered gray pattern @@ -152,16 +247,14 @@ int16 VideoDriverControl(uint32 pb, uint 0xffffffff // 32 bpp }; uint32 p = VidLocal.desc->mac_frame_base; - uint32 pat = pattern[VidLocal.desc->mode]; - for (uint32 y=0; yy; y++) { - uint32 p2 = p; - for (uint32 x=0; xbytes_per_row / 4; x++) { - WriteMacInt32(p2, pat); - p2 += 4; - if (VidLocal.desc->mode == VMODE_32BIT) + uint32 pat = pattern[VidLocal.desc->mode.depth]; + for (uint32 y=0; ymode.y; y++) { + for (uint32 x=0; xmode.bytes_per_row; x+=4) { + WriteMacInt32(p + x, pat); + if (VidLocal.desc->mode.depth == VDEPTH_32BIT) pat = ~pat; } - p += VidLocal.desc->bytes_per_row; + p += VidLocal.desc->mode.bytes_per_row; pat = ~pat; } return noErr; @@ -172,16 +265,48 @@ int16 VideoDriverControl(uint32 pb, uint VidLocal.luminance_mapping = ReadMacInt8(param + csMode); return noErr; - case cscSwitchMode: // Switch video mode - D(bug(" SwitchMode %04x, %08lx\n", ReadMacInt16(param + csMode), ReadMacInt32(param + csData))); - WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); - return noErr; - case cscSetInterrupt: // Enable/disable VBL D(bug(" SetInterrupt %02x\n", ReadMacInt8(param + csMode))); VidLocal.interrupts_enabled = (ReadMacInt8(param + csMode) == 0); return noErr; + // case cscDirectSetEntries: + + case cscSetDefaultMode: { // Set default color depth + uint16 mode = ReadMacInt16(param + csMode); + D(bug(" SetDefaultMode %04x\n", mode)); + VidLocal.preferred_mode = mode; + return noErr; + } + + case cscSwitchMode: { // Switch video mode (depth and resolution) + uint16 mode = ReadMacInt16(param + csMode); + uint32 id = ReadMacInt32(param + csData); + D(bug(" SwitchMode %04x, %08x\n", mode, id)); + + if (mode != VidLocal.current_mode || id != VidLocal.current_id) { + std::vector::const_iterator i = find_mode(mode, id); + if (i == VideoModes.end()) { + WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + return paramErr; + } + video_switch_to_mode(*i); + VidLocal.current_mode = mode; + VidLocal.current_id = id; + } + WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + return noErr; + } + + case cscSavePreferredConfiguration: { + 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; + return noErr; + } + default: printf("WARNING: Unknown VideoDriverControl(%d)\n", code); return controlErr; @@ -200,35 +325,46 @@ int16 VideoDriverStatus(uint32 pb, uint3 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); + WriteMacInt16(param + csPage, 0); + WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); + return noErr; + + // case cscGetEntries: + case cscGetPageCnt: // Get number of pages - D(bug(" GetPageCnt\n")); + D(bug(" GetPageCnt -> 1\n")); WriteMacInt16(param + csPage, 1); return noErr; case cscGetPageBase: // Get page base address - D(bug(" GetPageBase\n")); + D(bug(" GetPageBase -> %08x\n", VidLocal.desc->mac_frame_base)); WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); return noErr; case cscGetGray: // Get luminance mapping flag - D(bug(" GetGray\n")); - WriteMacInt8(param + csMode, VidLocal.luminance_mapping ? 1 : 0); + D(bug(" GetGray -> %d\n", VidLocal.luminance_mapping)); + WriteMacInt8(param, VidLocal.luminance_mapping ? 1 : 0); return noErr; case cscGetInterrupt: // Get interrupt disable flag - D(bug(" GetInterrupt\n")); - WriteMacInt8(param + csMode, VidLocal.interrupts_enabled ? 0 : 1); + D(bug(" GetInterrupt -> %d\n", VidLocal.interrupts_enabled)); + WriteMacInt8(param, VidLocal.interrupts_enabled ? 0 : 1); return noErr; - case cscGetDefaultMode: // Get default video mode - D(bug(" GetDefaultMode\n")); - WriteMacInt8(param + csMode, 0x80); + // case cscGetGamma: + + case cscGetDefaultMode: // Get default color depth + D(bug(" GetDefaultMode -> %04x\n", VidLocal.preferred_mode)); + WriteMacInt16(param + csMode, VidLocal.preferred_mode); return noErr; - case cscGetCurMode: // Get current video mode - D(bug(" GetCurMode\n")); - WriteMacInt16(param + csMode, 0x80); - WriteMacInt32(param + csData, 0x80); + case cscGetCurMode: // Get current video mode (depth and resolution) + D(bug(" GetCurMode -> %04x/%08x\n", VidLocal.current_mode, VidLocal.current_id)); + WriteMacInt16(param + csMode, VidLocal.current_mode); + WriteMacInt32(param + csData, VidLocal.current_id); WriteMacInt16(param + csPage, 0); WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); return noErr; @@ -242,25 +378,142 @@ int16 VideoDriverStatus(uint32 pb, uint3 WriteMacInt32(param + csDisplayComponent, 0); return noErr; - case cscGetModeTiming: // Get video timing for mode - D(bug(" GetModeTiming mode %08lx\n", ReadMacInt32(param + csTimingMode))); - WriteMacInt32(param + csTimingFormat, FOURCC('d', 'e', 'c', 'l')); - WriteMacInt32(param + csTimingData, 220); // 21" Multiscan - WriteMacInt32(param + csTimingFlags, 0x0f); // Mode valid, safe, default and shown in Monitors panel - return noErr; - case cscGetModeBaseAddress: // Get frame buffer base address - D(bug(" GetModeBaseAddress\n")); + D(bug(" GetModeBaseAddress -> %08x\n", VidLocal.desc->mac_frame_base)); WriteMacInt32(param + csBaseAddr, VidLocal.desc->mac_frame_base); // Base address of video RAM for the current DisplayModeID and relative bit depth return noErr; - case cscGetMode: // REQUIRED for MacsBug - D(bug(" GetMode\n")); - WriteMacInt16(param + csPageMode, 0x80); - WriteMacInt32(param + csPageData, 0x80); // Unused - WriteMacInt16(param + csPagePage, 0); // Current display page - WriteMacInt32(param + csPageBaseAddr, VidLocal.desc->mac_frame_base); + 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); + return noErr; + + case cscGetNextResolution: { // Called iteratively to obtain a list of all supported resolutions + uint32 id = ReadMacInt32(param + csPreviousDisplayModeID); + D(bug(" GetNextResolution %08x\n", id)); + + switch (id) { + case 0: + // Return current resolution + id = VidLocal.current_id; + break; + + case 0xfffffffe: + // Return first supported resolution + id = 0x80; + while (!has_resolution(id)) + id++; + break; + + default: + // Get next resolution + if (!has_resolution(id)) + return paramErr; + id++; + while (!has_resolution(id) && id < 0x100) + id++; + if (id == 0x100) { // No more resolutions + WriteMacInt32(param + csRIDisplayModeID, 0xfffffffd); + return noErr; + } + break; + } + + WriteMacInt32(param + csRIDisplayModeID, id); + uint32 x, y; + get_size_of_resolution(id, x, y); + WriteMacInt32(param + csHorizontalPixels, x); + WriteMacInt32(param + csVerticalLines, y); + WriteMacInt32(param + csRefreshRate, 75 << 16); + WriteMacInt16(param + csMaxDepthMode, DepthToAppleMode(max_depth_of_resolution(id))); + uint32 flags = 0xb; // mode valid, safe and shown in Monitors panel + if (id == VidLocal.preferred_id) + flags |= 4; // default mode + WriteMacInt32(param + csResolutionFlags, flags); return noErr; + } + + case cscGetVideoParameters: { // Get information about specified resolution/depth + uint32 id = ReadMacInt32(param + csDisplayModeID); + uint16 mode = ReadMacInt16(param + csDepthMode); + D(bug(" GetVideoParameters %04x/%08x\n", mode, id)); + + vector::const_iterator i = VideoModes.begin(), end = VideoModes.end(); + while (i != end) { + if (DepthToAppleMode(i->depth) == mode && i->resolution_id == id) { + uint32 vp = ReadMacInt32(param + csVPBlockPtr); + WriteMacInt32(vp + vpBaseOffset, 0); + WriteMacInt16(vp + vpRowBytes, i->bytes_per_row); + WriteMacInt16(vp + vpBounds, 0); + WriteMacInt16(vp + vpBounds + 2, 0); + WriteMacInt16(vp + vpBounds + 4, i->y); + WriteMacInt16(vp + vpBounds + 6, i->x); + WriteMacInt16(vp + vpVersion, 0); + WriteMacInt16(vp + vpPackType, 0); + WriteMacInt32(vp + vpPackSize, 0); + WriteMacInt32(vp + vpHRes, 0x00480000); + WriteMacInt32(vp + vpVRes, 0x00480000); + uint32 pix_type, pix_size, cmp_count, cmp_size, dev_type; + switch (i->depth) { + case VDEPTH_1BIT: + pix_type = 0; pix_size = 1; + cmp_count = 1; cmp_size = 1; + dev_type = 0; // CLUT + break; + case VDEPTH_2BIT: + pix_type = 0; pix_size = 2; + cmp_count = 1; cmp_size = 2; + dev_type = 0; // CLUT + break; + case VDEPTH_4BIT: + pix_type = 0; pix_size = 4; + cmp_count = 1; cmp_size = 4; + dev_type = 0; // CLUT + break; + case VDEPTH_8BIT: + pix_type = 0; pix_size = 8; + cmp_count = 1; cmp_size = 8; + dev_type = 0; // CLUT + break; + case VDEPTH_16BIT: + pix_type = 0x10; pix_size = 16; + cmp_count = 3; cmp_size = 5; + dev_type = 2; // direct + break; + case VDEPTH_32BIT: + pix_type = 0x10; pix_size = 32; + cmp_count = 3; cmp_size = 8; + dev_type = 2; // direct + break; + } + WriteMacInt16(vp + vpPixelType, pix_type); + WriteMacInt16(vp + vpPixelSize, pix_size); + WriteMacInt16(vp + vpCmpCount, cmp_count); + WriteMacInt16(vp + vpCmpSize, cmp_size); + WriteMacInt32(param + csPageCount, 1); + WriteMacInt32(param + csDeviceType, dev_type); + return noErr; + } + ++i; + } + return paramErr; // specified resolution/depth not supported + } + + case cscGetModeTiming: { // Get video timing for specified resolution + uint32 id = ReadMacInt32(param + csTimingMode); + D(bug(" GetModeTiming %08x\n", id)); + if (!has_resolution(id)) + return paramErr; + + 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) + flags |= 4; // default mode + WriteMacInt32(param + csTimingFlags, flags); + return noErr; + } default: printf("WARNING: Unknown VideoDriverStatus(%d)\n", code);