This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_ph_image.c
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
26
27
#include <Ph.h>
#include <photon/Pg.h>
#include "SDL_endian.h"
28
#include "SDL_video.h"
29
#include "../SDL_pixels_c.h"
30
#include "SDL_ph_video.h"
31
#include "SDL_ph_image_c.h"
32
#include "SDL_ph_modes_c.h"
33
#include "SDL_ph_gl.h"
36
ph_SetupImage(_THIS, SDL_Surface * screen)
38
39
PgColor_t *palette = NULL;
int type = 0;
40
int bpp;
41
42
bpp = screen->format->BitsPerPixel;
44
/* Determine image type */
45
46
47
switch (bpp) {
case 8:
{
48
49
50
type = Pg_IMAGE_PALETTE_BYTE;
}
break;
51
52
53
case 15:
{
type = Pg_IMAGE_DIRECT_555;
54
55
}
break;
56
57
58
case 16:
{
type = Pg_IMAGE_DIRECT_565;
59
60
}
break;
63
64
65
type = Pg_IMAGE_DIRECT_888;
}
break;
68
69
70
type = Pg_IMAGE_DIRECT_8888;
}
break;
73
SDL_SetError("ph_SetupImage(): unsupported bpp=%d !\n", bpp);
74
75
76
77
return -1;
}
break;
}
79
/* palette emulation code */
80
if ((bpp == 8) && (desktoppal == SDLPH_PAL_EMULATE)) {
81
/* creating image palette */
82
palette = SDL_malloc(_Pg_MAX_PALETTE * sizeof(PgColor_t));
83
84
85
if (palette == NULL) {
SDL_SetError
("ph_SetupImage(): can't allocate memory for palette !\n");
86
87
return -1;
}
88
PgGetPalette(palette);
89
90
/* using shared memory for speed (set last param to 1) */
91
if ((SDL_Image =
92
93
PhCreateImage(NULL, screen->w, screen->h, type, palette,
_Pg_MAX_PALETTE, 1)) == NULL) {
94
95
SDL_SetError
("ph_SetupImage(): PhCreateImage() failed for bpp=8 !\n");
96
SDL_free(palette);
97
98
return -1;
}
100
/* using shared memory for speed (set last param to 1) */
101
if ((SDL_Image =
102
103
PhCreateImage(NULL, screen->w, screen->h, type, NULL, 0,
1)) == NULL) {
104
105
106
SDL_SetError
("ph_SetupImage(): PhCreateImage() failed for bpp=%d !\n",
bpp);
107
108
return -1;
}
111
screen->pixels = SDL_Image->image;
112
screen->pitch = SDL_Image->bpl;
114
this->UpdateRects = ph_NormalUpdate;
116
return 0;
117
118
}
120
ph_SetupOCImage(_THIS, SDL_Surface * screen)
121
{
122
int type = 0;
123
int bpp;
124
125
OCImage.flags = screen->flags;
126
127
bpp = screen->format->BitsPerPixel;
129
/* Determine image type */
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
switch (bpp) {
case 8:
{
type = Pg_IMAGE_PALETTE_BYTE;
}
break;
case 15:
{
type = Pg_IMAGE_DIRECT_555;
}
break;
case 16:
{
type = Pg_IMAGE_DIRECT_565;
}
break;
case 24:
{
type = Pg_IMAGE_DIRECT_888;
}
break;
case 32:
{
type = Pg_IMAGE_DIRECT_8888;
}
break;
default:
{
158
SDL_SetError("ph_SetupOCImage(): unsupported bpp=%d !\n", bpp);
159
160
161
return -1;
}
break;
164
/* Currently offscreen contexts with the same bit depth as display bpp only can be created */
165
OCImage.offscreen_context =
166
167
PdCreateOffscreenContext(0, screen->w, screen->h,
Pg_OSC_MEM_PAGE_ALIGN);
169
170
171
if (OCImage.offscreen_context == NULL) {
SDL_SetError
("ph_SetupOCImage(): PdCreateOffscreenContext() function failed !\n");
172
173
174
return -1;
}
175
screen->pitch = OCImage.offscreen_context->pitch;
177
OCImage.dc_ptr =
178
(unsigned char *) PdGetOffscreenContextPtr(OCImage.offscreen_context);
180
181
182
if (OCImage.dc_ptr == NULL) {
SDL_SetError
("ph_SetupOCImage(): PdGetOffscreenContextPtr function failed !\n");
183
PhDCRelease(OCImage.offscreen_context);
184
185
186
return -1;
}
187
OCImage.FrameData0 = OCImage.dc_ptr;
188
189
190
OCImage.CurrentFrameData = OCImage.FrameData0;
OCImage.current = 0;
191
PhDCSetCurrent(OCImage.offscreen_context);
193
screen->pixels = OCImage.CurrentFrameData;
194
195
196
197
this->UpdateRects = ph_OCUpdate;
return 0;
198
199
}
201
ph_SetupFullScreenImage(_THIS, SDL_Surface * screen)
202
203
204
{
OCImage.flags = screen->flags;
205
/* Begin direct and fullscreen mode */
206
if (!ph_EnterFullScreen(this, screen, PH_ENTER_DIRECTMODE)) {
207
208
209
return -1;
}
210
/* store palette for fullscreen */
211
if ((screen->format->BitsPerPixel == 8) && (desktopbpp != 8)) {
212
213
PgGetPalette(savedpal);
PgGetPalette(syspalph);
214
215
216
}
OCImage.offscreen_context =
217
218
219
PdCreateOffscreenContext(0, 0, 0,
Pg_OSC_MAIN_DISPLAY | Pg_OSC_MEM_PAGE_ALIGN
| Pg_OSC_CRTC_SAFE);
220
221
222
if (OCImage.offscreen_context == NULL) {
SDL_SetError
("ph_SetupFullScreenImage(): PdCreateOffscreenContext() function failed !\n");
223
224
return -1;
}
225
226
227
if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
OCImage.offscreen_backcontext =
228
229
PdDupOffscreenContext(OCImage.offscreen_context,
Pg_OSC_MEM_PAGE_ALIGN | Pg_OSC_CRTC_SAFE);
230
231
232
if (OCImage.offscreen_backcontext == NULL) {
SDL_SetError
("ph_SetupFullScreenImage(): PdCreateOffscreenContext(back) function failed !\n");
233
return -1;
234
235
236
}
}
237
OCImage.FrameData0 =
238
(unsigned char *) PdGetOffscreenContextPtr(OCImage.offscreen_context);
239
240
241
if (OCImage.FrameData0 == NULL) {
SDL_SetError
("ph_SetupFullScreenImage(): PdGetOffscreenContextPtr() function failed !\n");
242
ph_DestroyImage(this, screen);
243
244
245
return -1;
}
246
247
if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
OCImage.FrameData1 =
248
249
(unsigned char *) PdGetOffscreenContextPtr(OCImage.
offscreen_backcontext);
250
251
252
if (OCImage.FrameData1 == NULL) {
SDL_SetError
("ph_SetupFullScreenImage(back): PdGetOffscreenContextPtr() function failed !\n");
253
ph_DestroyImage(this, screen);
254
255
256
return -1;
}
}
258
/* wait for the hardware */
259
260
PgFlush();
PgWaitHWIdle();
262
if ((screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
263
OCImage.current = 0;
264
PhDCSetCurrent(OCImage.offscreen_context);
265
266
screen->pitch = OCImage.offscreen_context->pitch;
screen->pixels = OCImage.FrameData0;
268
/* emulate 640x400 videomode */
269
270
271
272
if (videomode_emulatemode == 1) {
int i;
for (i = 0; i < 40; i++) {
273
274
SDL_memset(screen->pixels + screen->pitch * i, 0x00,
screen->pitch);
275
276
}
for (i = 440; i < 480; i++) {
277
278
SDL_memset(screen->pixels + screen->pitch * i, 0x00,
screen->pitch);
279
280
}
screen->pixels += screen->pitch * 40;
282
PgSwapDisplay(OCImage.offscreen_backcontext, 0);
284
OCImage.current = 0;
285
PhDCSetCurrent(OCImage.offscreen_context);
286
287
screen->pitch = OCImage.offscreen_context->pitch;
screen->pixels = OCImage.FrameData0;
288
289
/* emulate 640x400 videomode */
290
291
292
293
if (videomode_emulatemode == 1) {
int i;
for (i = 0; i < 40; i++) {
294
295
SDL_memset(screen->pixels + screen->pitch * i, 0x00,
screen->pitch);
296
297
}
for (i = 440; i < 480; i++) {
298
299
SDL_memset(screen->pixels + screen->pitch * i, 0x00,
screen->pitch);
300
301
}
screen->pixels += screen->pitch * 40;
305
this->UpdateRects = ph_OCDCUpdate;
307
/* wait for the hardware */
308
309
PgFlush();
PgWaitHWIdle();
311
312
313
return 0;
}
314
#if SDL_VIDEO_OPENGL
317
ph_SetupOpenGLImage(_THIS, SDL_Surface * screen)
318
{
319
this->UpdateRects = ph_OpenGLUpdate;
320
321
screen->pixels = NULL;
screen->pitch = NULL;
323
324
#if (_NTO_VERSION >= 630)
if ((screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
325
if (!ph_EnterFullScreen(this, screen, PH_IGNORE_DIRECTMODE)) {
326
327
screen->flags &= ~SDL_FULLSCREEN;
return -1;
329
330
}
#endif /* 6.3.0 */
332
333
334
if (ph_SetupOpenGLContext
(this, screen->w, screen->h, screen->format->BitsPerPixel,
screen->flags) != 0) {
335
screen->flags &= ~SDL_INTERNALOPENGL;
336
return -1;
339
return 0;
342
#endif /* SDL_VIDEO_OPENGL */
345
ph_DestroyImage(_THIS, SDL_Surface * screen)
348
#if SDL_VIDEO_OPENGL
349
350
351
if (screen->flags & SDL_INTERNALOPENGL) {
if (oglctx) {
#if (_NTO_VERSION < 630)
352
353
PhDCSetCurrent(NULL);
PhDCRelease(oglctx);
355
356
357
qnxgl_context_destroy(oglctx);
qnxgl_buffers_destroy(oglbuffers);
qnxgl_finish();
358
359
360
361
362
#endif /* 6.3.0 */
oglctx = NULL;
oglbuffers = NULL;
oglflags = 0;
oglbpp = 0;
364
365
#if (_NTO_VERSION >= 630)
if (currently_fullscreen) {
366
ph_LeaveFullScreen(this);
367
368
}
#endif /* 6.3.0 */
370
371
return;
}
372
#endif /* SDL_VIDEO_OPENGL */
374
if (currently_fullscreen) {
375
/* if we right now in 8bpp fullscreen we must release palette */
376
if ((screen->format->BitsPerPixel == 8) && (desktopbpp != 8)) {
377
378
379
380
PgSetPalette(syspalph, 0, -1, 0, 0, 0);
PgSetPalette(savedpal, 0, 0, _Pg_MAX_PALETTE,
Pg_PALSET_GLOBAL | Pg_PALSET_FORCE_EXPOSE, 0);
PgFlush();
382
ph_LeaveFullScreen(this);
385
if (OCImage.offscreen_context != NULL) {
386
PhDCRelease(OCImage.offscreen_context);
387
388
OCImage.offscreen_context = NULL;
OCImage.FrameData0 = NULL;
390
if (OCImage.offscreen_backcontext != NULL) {
391
PhDCRelease(OCImage.offscreen_backcontext);
392
OCImage.offscreen_backcontext = NULL;
393
394
OCImage.FrameData1 = NULL;
}
395
OCImage.CurrentFrameData = NULL;
397
if (SDL_Image) {
398
/* if palette allocated, free it */
399
if (SDL_Image->palette) {
400
SDL_free(SDL_Image->palette);
402
403
PgShmemDestroy(SDL_Image->image);
SDL_free(SDL_Image);
406
407
408
/* Must be zeroed everytime */
SDL_Image = NULL;
410
411
screen->pixels = NULL;
}
412
413
}
415
ph_UpdateHWInfo(_THIS)
416
417
418
419
420
{
PgVideoModeInfo_t vmode;
PgHWCaps_t hwcaps;
/* Update video ram amount */
421
if (PgGetGraphicsHWCaps(&hwcaps) < 0) {
422
423
SDL_SetError
("ph_UpdateHWInfo(): GetGraphicsHWCaps() function failed !\n");
424
425
return -1;
}
426
this->info.video_mem = hwcaps.currently_available_video_ram / 1024;
427
428
/* obtain current mode capabilities */
429
if (PgGetVideoModeInfo(hwcaps.current_video_mode, &vmode) < 0) {
430
431
SDL_SetError
("ph_UpdateHWInfo(): GetVideoModeInfo() function failed !\n");
432
433
434
return -1;
}
435
436
if ((vmode.mode_capabilities1 & PgVM_MODE_CAP1_OFFSCREEN) ==
PgVM_MODE_CAP1_OFFSCREEN) {
437
/* this is a special test for drivers which tries to lie about offscreen capability */
438
439
440
441
if (hwcaps.currently_available_video_ram != 0) {
this->info.hw_available = 1;
} else {
this->info.hw_available = 0;
444
445
446
this->info.hw_available = 0;
}
447
448
if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_RECTANGLE) ==
PgVM_MODE_CAP2_RECTANGLE) {
449
this->info.blit_fill = 1;
451
452
453
this->info.blit_fill = 0;
}
454
455
if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_BITBLT) ==
PgVM_MODE_CAP2_BITBLT) {
456
this->info.blit_hw = 1;
458
459
this->info.blit_hw = 0;
}
461
462
if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_ALPHA_BLEND) ==
PgVM_MODE_CAP2_ALPHA_BLEND) {
463
this->info.blit_hw_A = 1;
465
this->info.blit_hw_A = 0;
467
468
469
if ((vmode.mode_capabilities2 & PgVM_MODE_CAP2_CHROMA) ==
PgVM_MODE_CAP2_CHROMA) {
470
this->info.blit_hw_CC = 1;
472
this->info.blit_hw_CC = 0;
475
476
477
return 0;
}
479
ph_SetupUpdateFunction(_THIS, SDL_Surface * screen, Uint32 flags)
480
{
481
482
int setupresult = -1;
483
ph_DestroyImage(this, screen);
485
#if SDL_VIDEO_OPENGL
486
if (flags & SDL_INTERNALOPENGL) {
487
setupresult = ph_SetupOpenGLImage(this, screen);
490
if ((flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
491
setupresult = ph_SetupFullScreenImage(this, screen);
492
493
} else {
if ((flags & SDL_HWSURFACE) == SDL_HWSURFACE) {
494
setupresult = ph_SetupOCImage(this, screen);
496
setupresult = ph_SetupImage(this, screen);
499
#if SDL_VIDEO_OPENGL
502
if (setupresult != -1) {
503
ph_UpdateHWInfo(this);
504
}
506
return setupresult;
507
}
510
ph_AllocHWSurface(_THIS, SDL_Surface * surface)
511
{
512
513
PgHWCaps_t hwcaps;
514
if (surface->hwdata != NULL) {
515
SDL_SetError("ph_AllocHWSurface(): hwdata already exists!\n");
518
519
surface->hwdata = SDL_malloc(sizeof(struct private_hwdata));
SDL_memset(surface->hwdata, 0x00, sizeof(struct private_hwdata));
520
surface->hwdata->offscreenctx =
521
522
PdCreateOffscreenContext(0, surface->w, surface->h,
Pg_OSC_MEM_PAGE_ALIGN);
523
524
525
if (surface->hwdata->offscreenctx == NULL) {
SDL_SetError
("ph_AllocHWSurface(): PdCreateOffscreenContext() function failed !\n");
526
527
return -1;
}
528
surface->pixels = PdGetOffscreenContextPtr(surface->hwdata->offscreenctx);
529
if (surface->pixels == NULL) {
530
PhDCRelease(surface->hwdata->offscreenctx);
531
532
SDL_SetError
("ph_AllocHWSurface(): PdGetOffscreenContextPtr() function failed !\n");
533
534
return -1;
}
535
536
537
538
539
surface->pitch = surface->hwdata->offscreenctx->pitch;
surface->flags |= SDL_HWSURFACE;
surface->flags |= SDL_PREALLOC;
#if 0 /* FIXME */
540
/* create simple offscreen lock */
541
542
543
surface->hwdata->crlockparam.flags = 0;
if (PdCreateOffscreenLock
(surface->hwdata->offscreenctx, &surface->hwdata->crlockparam) != EOK)
545
546
PhDCRelease(surface->hwdata->offscreenctx);
SDL_SetError("ph_AllocHWSurface(): Can't create offscreen lock !\n");
547
548
549
550
551
return -1;
}
#endif /* 0 */
/* Update video ram amount */
552
553
554
if (PgGetGraphicsHWCaps(&hwcaps) < 0) {
PdDestroyOffscreenLock(surface->hwdata->offscreenctx);
PhDCRelease(surface->hwdata->offscreenctx);
555
556
SDL_SetError
("ph_AllocHWSurface(): GetGraphicsHWCaps() function failed !\n");
557
558
return -1;
}
559
this->info.video_mem = hwcaps.currently_available_video_ram / 1024;
560
561
return 0;
562
563
}
565
ph_FreeHWSurface(_THIS, SDL_Surface * surface)
566
{
567
568
PgHWCaps_t hwcaps;
569
if (surface->hwdata == NULL) {
570
SDL_SetError("ph_FreeHWSurface(): no hwdata!\n");
573
if (surface->hwdata->offscreenctx == NULL) {
574
SDL_SetError("ph_FreeHWSurface(): no offscreen context to delete!\n");
577
#if 0 /* FIXME */
578
/* unlock the offscreen context if it has been locked before destroy it */
579
580
if (PdIsOffscreenLocked(surface->hwdata->offscreenctx) == Pg_OSC_LOCKED) {
PdUnlockOffscreen(surface->hwdata->offscreenctx);
583
PdDestroyOffscreenLock(surface->hwdata->offscreenctx);
584
585
#endif /* 0 */
586
PhDCRelease(surface->hwdata->offscreenctx);
588
SDL_free(surface->hwdata);
589
surface->hwdata = NULL;
590
591
/* Update video ram amount */
592
if (PgGetGraphicsHWCaps(&hwcaps) < 0) {
593
594
SDL_SetError
("ph_FreeHWSurface(): GetGraphicsHWCaps() function failed !\n");
595
596
return;
}
597
this->info.video_mem = hwcaps.currently_available_video_ram / 1024;
599
return;
600
601
}
603
ph_CheckHWBlit(_THIS, SDL_Surface * src, SDL_Surface * dst)
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
if ((src->hwdata == NULL) && (src != this->screen)) {
SDL_SetError
("ph_CheckHWBlit(): Source surface haven't hardware specific data.\n");
src->flags &= ~SDL_HWACCEL;
return -1;
}
if ((src->flags & SDL_HWSURFACE) != SDL_HWSURFACE) {
SDL_SetError
("ph_CheckHWBlit(): Source surface isn't a hardware surface.\n");
src->flags &= ~SDL_HWACCEL;
return -1;
}
if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
if (this->info.blit_hw_CC != 1) {
src->flags &= ~SDL_HWACCEL;
src->map->hw_blit = NULL;
return -1;
}
}
if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
if (this->info.blit_hw_A != 1) {
src->flags &= ~SDL_HWACCEL;
src->map->hw_blit = NULL;
return -1;
}
}
src->flags |= SDL_HWACCEL;
src->map->hw_blit = ph_HWAccelBlit;
return 1;
641
ph_ExpandColor(_THIS, SDL_Surface * surface, Uint32 color)
642
643
644
645
{
Uint32 truecolor;
/* Photon API accepts true colors only during hw filling operations */
646
647
648
649
650
651
switch (surface->format->BitsPerPixel) {
case 8:
{
if ((surface->format->palette)
&& (color <= surface->format->palette->ncolors)) {
truecolor =
652
653
654
PgRGB(surface->format->palette->colors[color].r,
surface->format->palette->colors[color].g,
surface->format->palette->colors[color].b);
655
656
657
} else {
SDL_SetError
("ph_ExpandColor(): Color out of range for the 8bpp mode !\n");
658
659
return 0xFFFFFFFFUL;
}
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
}
break;
case 15:
{
truecolor = ((color & 0x00007C00UL) << 9) | /* R */
((color & 0x000003E0UL) << 6) | /* G */
((color & 0x0000001FUL) << 3) | /* B */
((color & 0x00007000UL) << 4) | /* R compensation */
((color & 0x00000380UL) << 1) | /* G compensation */
((color & 0x0000001CUL) >> 2); /* B compensation */
}
break;
case 16:
{
truecolor = ((color & 0x0000F800UL) << 8) | /* R */
((color & 0x000007E0UL) << 5) | /* G */
((color & 0x0000001FUL) << 3) | /* B */
((color & 0x0000E000UL) << 3) | /* R compensation */
((color & 0x00000600UL) >> 1) | /* G compensation */
((color & 0x0000001CUL) >> 2); /* B compensation */
}
break;
case 24:
{
truecolor = color & 0x00FFFFFFUL;
}
break;
case 32:
{
truecolor = color;
}
break;
default:
{
SDL_SetError
("ph_ExpandColor(): Unsupported depth for the hardware operations !\n");
return 0xFFFFFFFFUL;
}
699
700
701
702
703
}
return truecolor;
}
705
ph_FillHWRect(_THIS, SDL_Surface * surface, SDL_Rect * rect, Uint32 color)
706
707
708
{
PgColor_t oldcolor;
Uint32 truecolor;
709
int ydisp = 0;
711
712
if (this->info.blit_fill != 1) {
return -1;
715
truecolor = ph_ExpandColor(this, surface, color);
716
if (truecolor == 0xFFFFFFFFUL) {
717
718
719
return -1;
}
720
oldcolor = PgSetFillColor(truecolor);
721
722
/* 640x400 videomode emulation */
723
724
if (videomode_emulatemode == 1) {
ydisp += 40;
727
728
729
730
731
PgDrawIRect(rect->x, rect->y + ydisp, rect->w + rect->x - 1,
rect->h + rect->y + ydisp - 1, Pg_DRAW_FILL);
PgSetFillColor(oldcolor);
PgFlush();
PgWaitHWIdle();
732
733
734
735
return 0;
}
737
ph_FlipHWSurface(_THIS, SDL_Surface * screen)
738
{
739
740
PhArea_t farea;
741
if ((screen->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN) {
742
/* flush all drawing ops before blitting */
743
744
PgFlush();
PgWaitHWIdle();
746
747
748
749
farea.pos.x = 0;
farea.pos.y = 0;
farea.size.w = screen->w;
farea.size.h = screen->h;
750
751
/* emulate 640x400 videomode */
752
753
if (videomode_emulatemode == 1) {
farea.pos.y += 40;
756
757
PgContextBlitArea(OCImage.offscreen_context, &farea,
OCImage.offscreen_backcontext, &farea);
758
759
/* flush the blitting */
760
761
PgFlush();
PgWaitHWIdle();
762
763
764
765
}
return 0;
}
767
ph_LockHWSurface(_THIS, SDL_Surface * surface)
770
#if 0 /* FIXME */
771
772
int lockresult;
773
if (surface->hwdata == NULL) {
774
775
776
return;
}
777
778
779
surface->hwdata->lockparam.flags = 0;
surface->hwdata->lockparam.time_out = NULL;
lockresult =
780
781
PdLockOffscreen(surface->hwdata->offscreenctx,
&surface->hwdata->lockparam);
783
784
785
786
switch (lockresult) {
case EOK:
break;
case Pg_OSC_LOCK_DEADLOCK:
787
SDL_SetError("ph_LockHWSurface(): Deadlock detected !\n");
788
789
return -1;
case Pg_OSC_LOCK_INVALID:
790
SDL_SetError("ph_LockHWSurface(): Lock invalid !\n");
791
792
return -1;
default:
793
SDL_SetError("ph_LockHWSurface(): Can't lock the surface !\n");
795
796
797
798
799
800
}
#endif /* 0 */
return 0;
}
802
ph_UnlockHWSurface(_THIS, SDL_Surface * surface)
805
#if 0 /* FIXME */
806
807
int unlockresult;
808
if ((surface == NULL) || (surface->hwdata == NULL)) {
809
810
811
return;
}
812
813
if (PdIsOffscreenLocked(surface->hwdata->offscreenctx) == Pg_OSC_LOCKED) {
unlockresult = PdUnlockOffscreen(surface->hwdata->offscreenctx);
814
815
816
817
818
819
}
#endif /* 0 */
return;
}
821
822
ph_HWAccelBlit(SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst,
SDL_Rect * dstrect)
824
SDL_VideoDevice *this = current_video;
825
826
PhArea_t srcarea;
PhArea_t dstarea;
827
int ydisp = 0;
828
829
/* 640x400 videomode emulation */
830
831
if (videomode_emulatemode == 1) {
ydisp += 40;
834
835
836
837
srcarea.pos.x = srcrect->x;
srcarea.pos.y = srcrect->y;
srcarea.size.w = srcrect->w;
srcarea.size.h = srcrect->h;
839
840
841
842
dstarea.pos.x = dstrect->x;
dstarea.pos.y = dstrect->y;
dstarea.size.w = dstrect->w;
dstarea.size.h = dstrect->h;
844
845
846
if (((src == this->screen) || (src->hwdata != NULL))
&& ((dst == this->screen) || (dst->hwdata != NULL))) {
if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
847
848
ph_SetHWColorKey(this, src, src->format->colorkey);
PgChromaOn();
851
if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
852
853
ph_SetHWAlpha(this, src, src->format->alpha);
PgAlphaOn();
856
857
if (dst == this->screen) {
if (src == this->screen) {
858
/* blitting from main screen to main screen */
859
860
dstarea.pos.y += ydisp;
srcarea.pos.y += ydisp;
861
862
PgContextBlitArea(OCImage.offscreen_context, &srcarea,
OCImage.offscreen_context, &dstarea);
864
/* blitting from offscreen to main screen */
865
dstarea.pos.y += ydisp;
866
867
PgContextBlitArea(src->hwdata->offscreenctx, &srcarea,
OCImage.offscreen_context, &dstarea);
869
870
} else {
if (src == this->screen) {
871
/* blitting from main screen to offscreen */
872
srcarea.pos.y += ydisp;
873
874
PgContextBlitArea(OCImage.offscreen_context, &srcarea,
dst->hwdata->offscreenctx, &dstarea);
876
/* blitting offscreen to offscreen */
877
878
PgContextBlitArea(src->hwdata->offscreenctx, &srcarea,
dst->hwdata->offscreenctx, &dstarea);
879
880
881
}
}
882
if ((src->flags & SDL_SRCALPHA) == SDL_SRCALPHA) {
883
PgAlphaOff();
886
if ((src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
887
PgChromaOff();
889
890
891
} else {
SDL_SetError
("ph_HWAccelBlit(): Source or target surface is not a hardware surface !\n");
892
893
894
return -1;
}
895
896
PgFlush();
PgWaitHWIdle();
898
return 0;
899
900
}
902
ph_SetHWColorKey(_THIS, SDL_Surface * surface, Uint32 key)
903
{
904
905
if (this->info.blit_hw_CC != 1) {
return -1;
908
if (surface->hwdata != NULL) {
909
surface->hwdata->colorkey = ph_ExpandColor(this, surface, key);
910
if (surface->hwdata->colorkey == 0xFFFFFFFFUL) {
911
912
913
return -1;
}
}
914
915
PgSetChroma(surface->hwdata->colorkey,
Pg_CHROMA_SRC_MATCH | Pg_CHROMA_NODRAW);
916
917
return 0;
918
919
}
921
ph_SetHWAlpha(_THIS, SDL_Surface * surface, Uint8 alpha)
922
{
923
924
if (this->info.blit_hw_A != 1) {
return -1;
927
PgSetAlphaBlend(NULL, alpha);
928
929
return 0;
930
931
}
932
#if SDL_VIDEO_OPENGL
934
ph_OpenGLUpdate(_THIS, int numrects, SDL_Rect * rects)
936
this->GL_SwapBuffers(this);
940
#endif /* SDL_VIDEO_OPENGL */
943
ph_NormalUpdate(_THIS, int numrects, SDL_Rect * rects)
944
{
945
946
947
948
PhPoint_t ph_pos;
PhRect_t ph_rect;
int i;
949
950
for (i = 0; i < numrects; ++i) {
if (rects[i].w == 0) { /* Clipped? dunno why but this occurs sometime. */
951
continue;
952
953
}
954
if (rects[i].h == 0) { /* Clipped? dunno why but this occurs sometime. */
955
956
957
continue;
}
958
959
960
961
962
963
964
ph_pos.x = rects[i].x;
ph_pos.y = rects[i].y;
ph_rect.ul.x = rects[i].x;
ph_rect.ul.y = rects[i].y;
ph_rect.lr.x = rects[i].x + rects[i].w;
ph_rect.lr.y = rects[i].y + rects[i].h;
965
966
if (PgDrawPhImageRectmx(&ph_pos, SDL_Image, &ph_rect, 0) < 0) {
SDL_SetError("ph_NormalUpdate(): PgDrawPhImageRectmx failed!\n");
967
return;
968
969
}
}
971
972
if (PgFlush() < 0) {
SDL_SetError("ph_NormalUpdate(): PgFlush() function failed!\n");
973
974
}
}
977
ph_OCUpdate(_THIS, int numrects, SDL_Rect * rects)
978
{
979
980
int i;
981
PhPoint_t zero = { 0, 0 };
982
983
PhArea_t src_rect;
PhArea_t dest_rect;
985
986
987
PgSetTranslation(&zero, 0);
PgSetRegion(PtWidgetRid(window));
PgSetClipping(0, NULL);
989
990
PgFlush();
PgWaitHWIdle();
992
993
for (i = 0; i < numrects; ++i) {
if (rects[i].w == 0) { /* Clipped? */
994
continue;
995
996
}
997
if (rects[i].h == 0) { /* Clipped? */
998
999
continue;
}