1

/* $Id$ */

     2

     3

/******************************************************************************

     4

 *                             Cocoa video driver                             *

     5

 * Known things left to do:                                                   *

     6

 *  Scale&copy the old pixel buffer to the new one when switching resolution. *

     7

 ******************************************************************************/

     8

     9

#ifdef WITH_COCOA

    10

    11

#define MAC_OS_X_VERSION_MIN_REQUIRED    MAC_OS_X_VERSION_10_3

    12

#include <AvailabilityMacros.h>

    13

    14

#import <Cocoa/Cocoa.h>

    15

#import <sys/time.h> /* gettimeofday */

    16

#import <sys/param.h> /* for MAXPATHLEN */

    17

#import <unistd.h>

    18

    19

/**

    20

 * Important notice regarding all modifications!!!!!!!

    21

 * There are certain limitations because the file is objective C++.

    22

 * gdb has limitations.

    23

 * C++ and objective C code can't be joined in all cases (classes stuff).

    24

 * Read http://developer.apple.com/releasenotes/Cocoa/Objective-C++.html for more information.

    25

 */

    26

    27

    28

/* From Menus.h (according to Xcode Developer Documentation) */

    29

extern "C" void ShowMenuBar();

    30

extern "C" void HideMenuBar();

    31

    32

/* Defined in stdbool.h */

    33

#ifndef __cplusplus

    34

# ifndef __BEOS__

    35

#  undef bool

    36

#  undef false

    37

#  undef true

    38

# endif

    39

#endif

    40

    41

    42

#include "../../stdafx.h"

    43

#include "../../debug.h"

    45

#include "cocoa_v.h"

    47

    48

#undef Rect

    49

    50

    51

/* Structure for rez switch gamma fades

    52

 * We can hide the monitor flicker by setting the gamma tables to 0

    53

 */

    54

#define QZ_GAMMA_TABLE_SIZE 256

    55

    56

struct OTTD_QuartzGammaTable {

    57

	CGGammaValue red[QZ_GAMMA_TABLE_SIZE];

    58

	CGGammaValue green[QZ_GAMMA_TABLE_SIZE];

    59

	CGGammaValue blue[QZ_GAMMA_TABLE_SIZE];

    60

};

    61

    62

/* Add methods to get at private members of NSScreen.

    63

 * Since there is a bug in Apple's screen switching code that does not update

    64

 * this variable when switching to fullscreen, we'll set it manually (but only

    65

 * for the main screen).

    66

 */

    67

@interface NSScreen (NSScreenAccess)

    68

	- (void) setFrame:(NSRect)frame;

    69

@end

    70

    71

@implementation NSScreen (NSScreenAccess)

    72

- (void) setFrame:(NSRect)frame;

    73

{

    74

	_frame = frame;

    75

}

    76

@end

    77

    78

   159

class FullscreenSubdriver: public CocoaSubdriver {

   160

	int                display_width;

   161

	int                display_height;

   162

	int                display_depth;

   163

	int                screen_pitch;

   164

	void*              screen_buffer;

   165

	void*              pixel_buffer;

   166

   167

	CGDirectDisplayID  display_id;         /* 0 == main display (only support single display) */

   168

	CFDictionaryRef    cur_mode;           /* current mode of the display */

   169

	CFDictionaryRef    save_mode;          /* original mode of the display */

   170

	CGDirectPaletteRef palette;            /* palette of an 8-bit display */

   171

   172

	#define MAX_DIRTY_RECTS 100

   173

	Rect dirty_rects[MAX_DIRTY_RECTS];

   174

	int num_dirty_rects;

   175

   176

   177

	/* Gamma functions to try to hide the flash from a rez switch

   178

	 * Fade the display from normal to black

   179

	 * Save gamma tables for fade back to normal

   180

	 */

   181

	uint32 FadeGammaOut(OTTD_QuartzGammaTable* table)

   182

	{

   183

		CGGammaValue redTable[QZ_GAMMA_TABLE_SIZE];

   184

		CGGammaValue greenTable[QZ_GAMMA_TABLE_SIZE];

   185

		CGGammaValue blueTable[QZ_GAMMA_TABLE_SIZE];

   186

		float percent;

   187

		int j;

   188

		unsigned int actual;

   189

   190

		if (CGGetDisplayTransferByTable(

   191

					display_id, QZ_GAMMA_TABLE_SIZE,

   192

					table->red, table->green, table->blue, &actual

   193

				) != CGDisplayNoErr ||

   194

				actual != QZ_GAMMA_TABLE_SIZE) {

   195

			return 1;

   196

		}

   197

   198

		memcpy(redTable,   table->red,   sizeof(redTable));

   199

		memcpy(greenTable, table->green, sizeof(greenTable));

   200

		memcpy(blueTable,  table->blue,  sizeof(greenTable));

   201

   202

		for (percent = 1.0; percent >= 0.0; percent -= 0.01) {

   203

			for (j = 0; j < QZ_GAMMA_TABLE_SIZE; j++) {

   204

				redTable[j]   = redTable[j]   * percent;

   205

				greenTable[j] = greenTable[j] * percent;

   206

				blueTable[j]  = blueTable[j]  * percent;

   207

			}

   208

   209

			if (CGSetDisplayTransferByTable(

   210

						display_id, QZ_GAMMA_TABLE_SIZE,

   211

						redTable, greenTable, blueTable

   212

					) != CGDisplayNoErr) {

   213

				CGDisplayRestoreColorSyncSettings();

   214

				return 1;

   215

			}

   216

   217

			CSleep(10);

   218

		}

   219

   220

		return 0;

   221

	}

   222

   223

	/* Fade the display from black to normal

   224

	 * Restore previously saved gamma values

   225

	 */

   226

	uint32 FadeGammaIn(const OTTD_QuartzGammaTable* table)

   227

	{

   228

		CGGammaValue redTable[QZ_GAMMA_TABLE_SIZE];

   229

		CGGammaValue greenTable[QZ_GAMMA_TABLE_SIZE];

   230

		CGGammaValue blueTable[QZ_GAMMA_TABLE_SIZE];

   231

		float percent;

   232

		int j;

   233

   234

		memset(redTable, 0, sizeof(redTable));

   235

		memset(greenTable, 0, sizeof(greenTable));

   236

		memset(blueTable, 0, sizeof(greenTable));

   237

   238

		for (percent = 0.0; percent <= 1.0; percent += 0.01) {

   239

			for (j = 0; j < QZ_GAMMA_TABLE_SIZE; j++) {

   240

				redTable[j]   = table->red[j]   * percent;

   241

				greenTable[j] = table->green[j] * percent;

   242

				blueTable[j]  = table->blue[j]  * percent;

   243

			}

   244

   245

			if (CGSetDisplayTransferByTable(

   246

						display_id, QZ_GAMMA_TABLE_SIZE,

   247

						redTable, greenTable, blueTable

   248

					) != CGDisplayNoErr) {

   249

				CGDisplayRestoreColorSyncSettings();

   250

				return 1;

   251

			}

   252

   253

			CSleep(10);

   254

		}

   255

   256

		return 0;

   257

	}

   258

   259

	/* Wait for the VBL to occur (estimated since we don't have a hardware interrupt) */

   260

	void WaitForVerticalBlank()

   261

	{

   262

		/* The VBL delay is based on Ian Ollmann's RezLib <iano@cco.caltech.edu> */

   263

		double refreshRate;

   264

		double linesPerSecond;

   265

		double target;

   266

		double position;

   267

		double adjustment;

   268

		CFNumberRef refreshRateCFNumber;

   269

   270

		refreshRateCFNumber = (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayRefreshRate);

   271

		if (refreshRateCFNumber == NULL) return;

   272

   273

		if (CFNumberGetValue(refreshRateCFNumber, kCFNumberDoubleType, &refreshRate) == 0)

   274

			return;

   275

   276

		if (refreshRate == 0) return;

   277

   278

		linesPerSecond = refreshRate * display_height;

   279

		target = display_height;

   280

   281

		/* Figure out the first delay so we start off about right */

   282

		position = CGDisplayBeamPosition(display_id);

   283

		if (position > target) position = 0;

   284

   285

		adjustment = (target - position) / linesPerSecond;

   286

   287

		CSleep((uint32)(adjustment * 1000));

   288

	}

   289

   290

   291

	bool SetVideoMode(int w, int h)

   292

	{

   293

		int exact_match;

   294

		CFNumberRef number;

   295

		int bpp;

   296

		int gamma_error;

   297

		OTTD_QuartzGammaTable gamma_table;

   298

		NSRect screen_rect;

   299

		CGError error;

   300

		NSPoint pt;

   301

   302

		/* Destroy any previous mode */

   303

		if (pixel_buffer != NULL) {

   304

			free(pixel_buffer);

   305

			pixel_buffer = NULL;

   306

		}

   307

   308

		/* See if requested mode exists */

   309

		cur_mode = CGDisplayBestModeForParameters(display_id, display_depth, w, h, &exact_match);

   310

   311

		/* If the mode wasn't an exact match, check if it has the right bpp, and update width and height */

   312

		if (!exact_match) {

   313

			number = (const __CFNumber*) CFDictionaryGetValue(cur_mode, kCGDisplayBitsPerPixel);

   314

			CFNumberGetValue(number, kCFNumberSInt32Type, &bpp);

   315

			if (bpp != display_depth) {

   316

				DEBUG(driver, 0, "Failed to find display resolution");

   317

				goto ERR_NO_MATCH;

   318

			}

   319

   320

			number = (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayWidth);

   321

			CFNumberGetValue(number, kCFNumberSInt32Type, &w);

   322

   323

			number = (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayHeight);

   324

			CFNumberGetValue(number, kCFNumberSInt32Type, &h);

   325

		}

   326

   327

		/* Fade display to zero gamma */

   328

		gamma_error = FadeGammaOut(&gamma_table);

   329

   330

		/* Put up the blanking window (a window above all other windows) */

   331

		error = CGDisplayCapture(display_id);

   332

   333

		if (CGDisplayNoErr != error) {

   334

			DEBUG(driver, 0, "Failed capturing display");

   335

			goto ERR_NO_CAPTURE;

   336

		}

   337

   338

		/* Do the physical switch */

   339

		if (CGDisplaySwitchToMode(display_id, cur_mode) != CGDisplayNoErr) {

   340

			DEBUG(driver, 0, "Failed switching display resolution");

   341

			goto ERR_NO_SWITCH;

   342

		}

   343

   344

		screen_buffer = CGDisplayBaseAddress(display_id);

   345

		screen_pitch  = CGDisplayBytesPerRow(display_id);

   346

   347

		display_width = CGDisplayPixelsWide(display_id);

   348

		display_height = CGDisplayPixelsHigh(display_id);

   349

   350

		/* Setup double-buffer emulation */

   351

		pixel_buffer = malloc(display_width * display_height * display_depth / 8);

   352

		if (pixel_buffer == NULL) {

   353

			DEBUG(driver, 0, "Failed to allocate memory for double buffering");

   354

			goto ERR_DOUBLEBUF;

   355

		}

   356

   357

		if (display_depth == 8 && !CGDisplayCanSetPalette(display_id)) {

   358

			DEBUG(driver, 0, "Not an indexed display mode.");

   359

			goto ERR_NOT_INDEXED;

   360

		}

   361

   362

		/* If we don't hide menu bar, it will get events and interrupt the program */

   363

		HideMenuBar();

   364

   365

		/* Fade the display to original gamma */

   366

		if (!gamma_error) FadeGammaIn(&gamma_table);

   367

   368

		/* There is a bug in Cocoa where NSScreen doesn't synchronize

   369

		 * with CGDirectDisplay, so the main screen's frame is wrong.

   370

		 * As a result, coordinate translation produces incorrect results.

   371

		 * We can hack around this bug by setting the screen rect ourselves.

   372

		 * This hack should be removed if/when the bug is fixed.

   373

		*/

   374

		screen_rect = NSMakeRect(0, 0, display_width, display_height);

   375

		[ [ NSScreen mainScreen ] setFrame:screen_rect ];

   376

   377

   378

		pt = [ NSEvent mouseLocation ];

   379

		pt.y = display_height - pt.y;

   380

		if (MouseIsInsideView(&pt)) QZ_HideMouse();

   381

   382

		UpdatePalette(0, 256);

   383

   384

		return true;

   385

   386

		/* Since the blanking window covers *all* windows (even force quit) correct recovery is crucial */

   387

ERR_NOT_INDEXED:

   388

		free(pixel_buffer);

   389

		pixel_buffer = NULL;

   390

ERR_DOUBLEBUF:

   391

		CGDisplaySwitchToMode(display_id, save_mode);

   392

ERR_NO_SWITCH:

   393

		CGReleaseAllDisplays();

   394

ERR_NO_CAPTURE:

   395

		if (!gamma_error) FadeGammaIn(&gamma_table);

   396

ERR_NO_MATCH:

   397

		display_width = 0;

   398

		display_height = 0;

   399

   400

		return false;

   401

	}

   402

   403

	void RestoreVideoMode()

   404

	{

   405

		/* Release fullscreen resources */

   406

		OTTD_QuartzGammaTable gamma_table;

   407

		int gamma_error;

   408

		NSRect screen_rect;

   409

   410

		gamma_error = FadeGammaOut(&gamma_table);

   411

   412

		/* Restore original screen resolution/bpp */

   413

		CGDisplaySwitchToMode(display_id, save_mode);

   414

		CGReleaseAllDisplays();

   415

		ShowMenuBar();

   416

		/* Reset the main screen's rectangle

   417

		 * See comment in SetVideoMode for why we do this

   418

		 */

   419

		screen_rect = NSMakeRect(0, 0, CGDisplayPixelsWide(display_id), CGDisplayPixelsHigh(display_id));

   420

		[ [ NSScreen mainScreen ] setFrame:screen_rect ];

   421

   422

		QZ_ShowMouse();

   423

   424

		/* Destroy the pixel buffer */

   425

		if (pixel_buffer != NULL) {

   426

			free(pixel_buffer);

   427

			pixel_buffer = NULL;

   428

		}

   429

   430

		if (!gamma_error) FadeGammaIn(&gamma_table);

   431

   432

		display_width = 0;

   433

		display_height = 0;

   434

	}

   435

   436

public:

   437

	FullscreenSubdriver(int bpp)

   438

	{

   439

		if (bpp != 8 && bpp != 32) {

   440

			error("Cocoa: This video driver only supports 8 and 32 bpp blitters.");

   441

		}

   442

   443

		/* Initialize the video settings; this data persists between mode switches */

   444

		display_id = kCGDirectMainDisplay;

   445

		save_mode  = CGDisplayCurrentMode(display_id);

   446

   447

		if (bpp == 8) palette = CGPaletteCreateDefaultColorPalette();

   448

   449

		display_width  = 0;

   450

		display_height = 0;

   451

		display_depth  = bpp;

   452

		pixel_buffer   = NULL;

   453

   454

		num_dirty_rects = MAX_DIRTY_RECTS;

   455

	}

   456

   457

	virtual ~FullscreenSubdriver()

   458

	{

   459

		RestoreVideoMode();

   460

	}

   461

   462

	virtual void Draw()

   463

	{

   464

		const uint8* src   = (uint8*) pixel_buffer;

   465

		uint8* dst         = (uint8*) screen_buffer;

   466

		uint pitch         = screen_pitch;

   467

		uint width         = display_width;

   468

		uint num_dirty     = num_dirty_rects;

   469

		uint bytesperpixel = display_depth / 8;

   470

		uint i;

   471

   472

		/* Check if we need to do anything */

   473

		if (num_dirty == 0) return;

   474

   475

		if (num_dirty >= MAX_DIRTY_RECTS) {

   476

			num_dirty = 1;

   477

			dirty_rects[0].left   = 0;

   478

			dirty_rects[0].top    = 0;

   479

			dirty_rects[0].right  = display_width;

   480

			dirty_rects[0].bottom = display_height;

   481

		}

   482

   483

		WaitForVerticalBlank();

   484

		/* Build the region of dirty rectangles */

   485

		for (i = 0; i < num_dirty; i++) {

   486

			uint y      = dirty_rects[i].top;

   487

			uint left   = dirty_rects[i].left;

   488

			uint length = dirty_rects[i].right - left;

   489

			uint bottom = dirty_rects[i].bottom;

   490

   491

			for (; y < bottom; y++) {

   492

				memcpy(dst + y * pitch + left * bytesperpixel, src + y * width * bytesperpixel + left * bytesperpixel, length * bytesperpixel);

   493

			}

   494

		}

   495

   496

		num_dirty_rects = 0;

   497

	}

   498

   499

	virtual void MakeDirty(int left, int top, int width, int height)

   500

	{

   501

		if (num_dirty_rects < MAX_DIRTY_RECTS) {

   502

			dirty_rects[num_dirty_rects].left = left;

   503

			dirty_rects[num_dirty_rects].top = top;

   504

			dirty_rects[num_dirty_rects].right = left + width;

   505

			dirty_rects[num_dirty_rects].bottom = top + height;

   506

		}

   507

		num_dirty_rects++;

   508

	}

   509

   510

	virtual void UpdatePalette(uint first_color, uint num_colors)

   511

	{

   512

		CGTableCount  index;

   513

		CGDeviceColor color;

   514

   515

		if (display_depth != 8)

   516

			return;

   517

   518

		for (index = first_color; index < first_color+num_colors; index++) {

   519

			/* Clamp colors between 0.0 and 1.0 */

   520

			color.red   = _cur_palette[index].r / 255.0;

   521

			color.blue  = _cur_palette[index].b / 255.0;

   522

			color.green = _cur_palette[index].g / 255.0;

   523

   524

			CGPaletteSetColorAtIndex(palette, color, index);