1 /*
2 (c) Copyright 2001-2011 The world wide DirectFB Open Source Community (directfb.org)
3 (c) Copyright 2000-2004 Convergence (integrated media) GmbH
4
5 All rights reserved.
6
7 Written by Denis Oliver Kropp <dok@directfb.org>,
8 Andreas Hundt <andi@fischlustig.de>,
9 Sven Neumann <neo@directfb.org>,
10 Ville Syrjälä <syrjala@sci.fi> and
11 Claudio Ciccani <klan@users.sf.net>.
12
13 This library is free software; you can redistribute it and/or
14 modify it under the terms of the GNU Lesser General Public
15 License as published by the Free Software Foundation; either
16 version 2 of the License, or (at your option) any later version.
17
18 This library is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 Lesser General Public License for more details.
22
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, write to the
25 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
26 Boston, MA 02111-1307, USA.
27 */
28
29 #include <config.h>
30
31 #include "CoreSurface.h"
32
33 #include <directfb_util.h>
34
35 #include <direct/debug.h>
36 #include <direct/mem.h>
37 #include <direct/memcpy.h>
38 #include <direct/messages.h>
39
40 #include <fusion/conf.h>
41
42 #include <core/core.h>
43
44 #include <core/CoreDFB_CallMode.h>
45
46 D_DEBUG_DOMAIN( DirectFB_CoreSurface, "DirectFB/CoreSurface", "DirectFB CoreSurface" );
47
48 /*********************************************************************************************************************/
49
50 DFBResult
CoreSurface_SetConfig(CoreSurface * obj,const CoreSurfaceConfig * config)51 CoreSurface_SetConfig(
52 CoreSurface *obj,
53 const CoreSurfaceConfig *config
54 )
55 {
56 DFBResult ret;
57
58 switch (CoreDFB_CallMode( core_dfb )) {
59 case COREDFB_CALL_DIRECT:{
60 Core_PushCalling();
61 ret = ISurface_Real__SetConfig( obj, config );
62 Core_PopCalling();
63
64 return ret;
65 }
66
67 case COREDFB_CALL_INDIRECT: {
68 Core_PushCalling();
69 ret = ISurface_Requestor__SetConfig( obj, config );
70 Core_PopCalling();
71
72 return ret;
73 }
74 case COREDFB_CALL_DENY:
75 return DFB_DEAD;
76 }
77
78 return DFB_UNIMPLEMENTED;
79 }
80
81 DFBResult
CoreSurface_Flip(CoreSurface * obj,bool swap)82 CoreSurface_Flip(
83 CoreSurface *obj,
84 bool swap
85 )
86 {
87 DFBResult ret;
88
89 switch (CoreDFB_CallMode( core_dfb )) {
90 case COREDFB_CALL_DIRECT:{
91 Core_PushCalling();
92 ret = ISurface_Real__Flip( obj, swap );
93 Core_PopCalling();
94
95 return ret;
96 }
97
98 case COREDFB_CALL_INDIRECT: {
99 Core_PushCalling();
100 ret = ISurface_Requestor__Flip( obj, swap );
101 Core_PopCalling();
102
103 return ret;
104 }
105 case COREDFB_CALL_DENY:
106 return DFB_DEAD;
107 }
108
109 return DFB_UNIMPLEMENTED;
110 }
111
112 DFBResult
CoreSurface_GetPalette(CoreSurface * obj,CorePalette ** ret_palette)113 CoreSurface_GetPalette(
114 CoreSurface *obj,
115 CorePalette **ret_palette
116 )
117 {
118 DFBResult ret;
119
120 switch (CoreDFB_CallMode( core_dfb )) {
121 case COREDFB_CALL_DIRECT:{
122 Core_PushCalling();
123 ret = ISurface_Real__GetPalette( obj, ret_palette );
124 Core_PopCalling();
125
126 return ret;
127 }
128
129 case COREDFB_CALL_INDIRECT: {
130 Core_PushCalling();
131 ret = ISurface_Requestor__GetPalette( obj, ret_palette );
132 Core_PopCalling();
133
134 return ret;
135 }
136 case COREDFB_CALL_DENY:
137 return DFB_DEAD;
138 }
139
140 return DFB_UNIMPLEMENTED;
141 }
142
143 DFBResult
CoreSurface_SetPalette(CoreSurface * obj,CorePalette * palette)144 CoreSurface_SetPalette(
145 CoreSurface *obj,
146 CorePalette *palette
147 )
148 {
149 DFBResult ret;
150
151 switch (CoreDFB_CallMode( core_dfb )) {
152 case COREDFB_CALL_DIRECT:{
153 Core_PushCalling();
154 ret = ISurface_Real__SetPalette( obj, palette );
155 Core_PopCalling();
156
157 return ret;
158 }
159
160 case COREDFB_CALL_INDIRECT: {
161 Core_PushCalling();
162 ret = ISurface_Requestor__SetPalette( obj, palette );
163 Core_PopCalling();
164
165 return ret;
166 }
167 case COREDFB_CALL_DENY:
168 return DFB_DEAD;
169 }
170
171 return DFB_UNIMPLEMENTED;
172 }
173
174 DFBResult
CoreSurface_SetAlphaRamp(CoreSurface * obj,u8 a0,u8 a1,u8 a2,u8 a3)175 CoreSurface_SetAlphaRamp(
176 CoreSurface *obj,
177 u8 a0,
178 u8 a1,
179 u8 a2,
180 u8 a3
181 )
182 {
183 DFBResult ret;
184
185 switch (CoreDFB_CallMode( core_dfb )) {
186 case COREDFB_CALL_DIRECT:{
187 Core_PushCalling();
188 ret = ISurface_Real__SetAlphaRamp( obj, a0, a1, a2, a3 );
189 Core_PopCalling();
190
191 return ret;
192 }
193
194 case COREDFB_CALL_INDIRECT: {
195 Core_PushCalling();
196 ret = ISurface_Requestor__SetAlphaRamp( obj, a0, a1, a2, a3 );
197 Core_PopCalling();
198
199 return ret;
200 }
201 case COREDFB_CALL_DENY:
202 return DFB_DEAD;
203 }
204
205 return DFB_UNIMPLEMENTED;
206 }
207
208 DFBResult
CoreSurface_SetField(CoreSurface * obj,s32 field)209 CoreSurface_SetField(
210 CoreSurface *obj,
211 s32 field
212 )
213 {
214 DFBResult ret;
215
216 switch (CoreDFB_CallMode( core_dfb )) {
217 case COREDFB_CALL_DIRECT:{
218 Core_PushCalling();
219 ret = ISurface_Real__SetField( obj, field );
220 Core_PopCalling();
221
222 return ret;
223 }
224
225 case COREDFB_CALL_INDIRECT: {
226 Core_PushCalling();
227 ret = ISurface_Requestor__SetField( obj, field );
228 Core_PopCalling();
229
230 return ret;
231 }
232 case COREDFB_CALL_DENY:
233 return DFB_DEAD;
234 }
235
236 return DFB_UNIMPLEMENTED;
237 }
238
239 DFBResult
CoreSurface_PreLockBuffer(CoreSurface * obj,CoreSurfaceBuffer * buffer,CoreSurfaceAccessorID accessor,CoreSurfaceAccessFlags access,CoreSurfaceAllocation ** ret_allocation)240 CoreSurface_PreLockBuffer(
241 CoreSurface *obj,
242 CoreSurfaceBuffer *buffer,
243 CoreSurfaceAccessorID accessor,
244 CoreSurfaceAccessFlags access,
245 CoreSurfaceAllocation **ret_allocation
246 )
247 {
248 DFBResult ret;
249
250 switch (CoreDFB_CallMode( core_dfb )) {
251 case COREDFB_CALL_DIRECT:{
252 Core_PushCalling();
253 ret = ISurface_Real__PreLockBuffer( obj, buffer, accessor, access, ret_allocation );
254 Core_PopCalling();
255
256 return ret;
257 }
258
259 case COREDFB_CALL_INDIRECT: {
260 Core_PushCalling();
261 ret = ISurface_Requestor__PreLockBuffer( obj, buffer, accessor, access, ret_allocation );
262 Core_PopCalling();
263
264 return ret;
265 }
266 case COREDFB_CALL_DENY:
267 return DFB_DEAD;
268 }
269
270 return DFB_UNIMPLEMENTED;
271 }
272
273 DFBResult
CoreSurface_PreLockBuffer2(CoreSurface * obj,CoreSurfaceBufferRole role,CoreSurfaceAccessorID accessor,CoreSurfaceAccessFlags access,bool lock,CoreSurfaceAllocation ** ret_allocation)274 CoreSurface_PreLockBuffer2(
275 CoreSurface *obj,
276 CoreSurfaceBufferRole role,
277 CoreSurfaceAccessorID accessor,
278 CoreSurfaceAccessFlags access,
279 bool lock,
280 CoreSurfaceAllocation **ret_allocation
281 )
282 {
283 DFBResult ret;
284
285 switch (CoreDFB_CallMode( core_dfb )) {
286 case COREDFB_CALL_DIRECT:{
287 Core_PushCalling();
288 ret = ISurface_Real__PreLockBuffer2( obj, role, accessor, access, lock, ret_allocation );
289 Core_PopCalling();
290
291 return ret;
292 }
293
294 case COREDFB_CALL_INDIRECT: {
295 Core_PushCalling();
296 ret = ISurface_Requestor__PreLockBuffer2( obj, role, accessor, access, lock, ret_allocation );
297 Core_PopCalling();
298
299 return ret;
300 }
301 case COREDFB_CALL_DENY:
302 return DFB_DEAD;
303 }
304
305 return DFB_UNIMPLEMENTED;
306 }
307
308 DFBResult
CoreSurface_PreReadBuffer(CoreSurface * obj,CoreSurfaceBuffer * buffer,const DFBRectangle * rect,CoreSurfaceAllocation ** ret_allocation)309 CoreSurface_PreReadBuffer(
310 CoreSurface *obj,
311 CoreSurfaceBuffer *buffer,
312 const DFBRectangle *rect,
313 CoreSurfaceAllocation **ret_allocation
314 )
315 {
316 DFBResult ret;
317
318 switch (CoreDFB_CallMode( core_dfb )) {
319 case COREDFB_CALL_DIRECT:{
320 Core_PushCalling();
321 ret = ISurface_Real__PreReadBuffer( obj, buffer, rect, ret_allocation );
322 Core_PopCalling();
323
324 return ret;
325 }
326
327 case COREDFB_CALL_INDIRECT: {
328 Core_PushCalling();
329 ret = ISurface_Requestor__PreReadBuffer( obj, buffer, rect, ret_allocation );
330 Core_PopCalling();
331
332 return ret;
333 }
334 case COREDFB_CALL_DENY:
335 return DFB_DEAD;
336 }
337
338 return DFB_UNIMPLEMENTED;
339 }
340
341 DFBResult
CoreSurface_PreWriteBuffer(CoreSurface * obj,CoreSurfaceBuffer * buffer,const DFBRectangle * rect,CoreSurfaceAllocation ** ret_allocation)342 CoreSurface_PreWriteBuffer(
343 CoreSurface *obj,
344 CoreSurfaceBuffer *buffer,
345 const DFBRectangle *rect,
346 CoreSurfaceAllocation **ret_allocation
347 )
348 {
349 DFBResult ret;
350
351 switch (CoreDFB_CallMode( core_dfb )) {
352 case COREDFB_CALL_DIRECT:{
353 Core_PushCalling();
354 ret = ISurface_Real__PreWriteBuffer( obj, buffer, rect, ret_allocation );
355 Core_PopCalling();
356
357 return ret;
358 }
359
360 case COREDFB_CALL_INDIRECT: {
361 Core_PushCalling();
362 ret = ISurface_Requestor__PreWriteBuffer( obj, buffer, rect, ret_allocation );
363 Core_PopCalling();
364
365 return ret;
366 }
367 case COREDFB_CALL_DENY:
368 return DFB_DEAD;
369 }
370
371 return DFB_UNIMPLEMENTED;
372 }
373
374 /*********************************************************************************************************************/
375
376 static FusionCallHandlerResult
CoreSurface_Dispatch(int caller,int call_arg,void * ptr,unsigned int length,void * ctx,unsigned int serial,void * ret_ptr,unsigned int ret_size,unsigned int * ret_length)377 CoreSurface_Dispatch( int caller, /* fusion id of the caller */
378 int call_arg, /* optional call parameter */
379 void *ptr, /* optional call parameter */
380 unsigned int length,
381 void *ctx, /* optional handler context */
382 unsigned int serial,
383 void *ret_ptr,
384 unsigned int ret_size,
385 unsigned int *ret_length )
386 {
387 CoreSurface *obj = (CoreSurface*) ctx;
388 CoreSurfaceDispatch__Dispatch( obj, caller, call_arg, ptr, length, ret_ptr, ret_size, ret_length );
389
390 return FCHR_RETURN;
391 }
392
CoreSurface_Init_Dispatch(CoreDFB * core,CoreSurface * obj,FusionCall * call)393 void CoreSurface_Init_Dispatch(
394 CoreDFB *core,
395 CoreSurface *obj,
396 FusionCall *call
397 )
398 {
399 fusion_call_init3( call, CoreSurface_Dispatch, obj, core->world );
400 }
401
CoreSurface_Deinit_Dispatch(FusionCall * call)402 void CoreSurface_Deinit_Dispatch(
403 FusionCall *call
404 )
405 {
406 fusion_call_destroy( call );
407 }
408
409 /*********************************************************************************************************************/
410
411
412 DFBResult
ISurface_Requestor__SetConfig(CoreSurface * obj,const CoreSurfaceConfig * config)413 ISurface_Requestor__SetConfig( CoreSurface *obj,
414 const CoreSurfaceConfig *config
415 )
416 {
417 DFBResult ret;
418 CoreSurfaceSetConfig *args = (CoreSurfaceSetConfig*) alloca( sizeof(CoreSurfaceSetConfig) );
419 CoreSurfaceSetConfigReturn *return_args = (CoreSurfaceSetConfigReturn*) alloca( sizeof(CoreSurfaceSetConfigReturn) );
420
421 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
422
423 D_ASSERT( config != NULL );
424
425 args->config = *config;
426
427 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_SetConfig, args, sizeof(CoreSurfaceSetConfig), return_args, sizeof(CoreSurfaceSetConfigReturn), NULL );
428 if (ret) {
429 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_SetConfig ) failed!\n", __FUNCTION__ );
430 return ret;
431 }
432
433 if (return_args->result) {
434 /*D_DERROR( return_args->result, "%s: CoreSurface_SetConfig failed!\n", __FUNCTION__ );*/
435 return return_args->result;
436 }
437
438
439 return DFB_OK;
440 }
441
442
443 DFBResult
ISurface_Requestor__Flip(CoreSurface * obj,bool swap)444 ISurface_Requestor__Flip( CoreSurface *obj,
445 bool swap
446 )
447 {
448 DFBResult ret;
449 CoreSurfaceFlip *args = (CoreSurfaceFlip*) alloca( sizeof(CoreSurfaceFlip) );
450 CoreSurfaceFlipReturn *return_args = (CoreSurfaceFlipReturn*) alloca( sizeof(CoreSurfaceFlipReturn) );
451
452 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
453
454
455 args->swap = swap;
456
457 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_Flip, args, sizeof(CoreSurfaceFlip), return_args, sizeof(CoreSurfaceFlipReturn), NULL );
458 if (ret) {
459 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_Flip ) failed!\n", __FUNCTION__ );
460 return ret;
461 }
462
463 if (return_args->result) {
464 /*D_DERROR( return_args->result, "%s: CoreSurface_Flip failed!\n", __FUNCTION__ );*/
465 return return_args->result;
466 }
467
468
469 return DFB_OK;
470 }
471
472
473 DFBResult
ISurface_Requestor__GetPalette(CoreSurface * obj,CorePalette ** ret_palette)474 ISurface_Requestor__GetPalette( CoreSurface *obj,
475 CorePalette **ret_palette
476 )
477 {
478 DFBResult ret;
479 CorePalette *palette = NULL;
480 CoreSurfaceGetPalette *args = (CoreSurfaceGetPalette*) alloca( sizeof(CoreSurfaceGetPalette) );
481 CoreSurfaceGetPaletteReturn *return_args = (CoreSurfaceGetPaletteReturn*) alloca( sizeof(CoreSurfaceGetPaletteReturn) );
482
483 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
484
485 D_ASSERT( ret_palette != NULL );
486
487
488 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_GetPalette, args, sizeof(CoreSurfaceGetPalette), return_args, sizeof(CoreSurfaceGetPaletteReturn), NULL );
489 if (ret) {
490 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_GetPalette ) failed!\n", __FUNCTION__ );
491 return ret;
492 }
493
494 if (return_args->result) {
495 /*D_DERROR( return_args->result, "%s: CoreSurface_GetPalette failed!\n", __FUNCTION__ );*/
496 return return_args->result;
497 }
498
499
500 ret = (DFBResult) CorePalette_Catch( core_dfb, return_args->palette_id, &palette );
501 if (ret) {
502 D_DERROR( ret, "%s: Catching palette by ID %u failed!\n", __FUNCTION__, return_args->palette_id );
503 return ret;
504 }
505
506 *ret_palette = palette;
507
508 return DFB_OK;
509 }
510
511
512 DFBResult
ISurface_Requestor__SetPalette(CoreSurface * obj,CorePalette * palette)513 ISurface_Requestor__SetPalette( CoreSurface *obj,
514 CorePalette *palette
515 )
516 {
517 DFBResult ret;
518 CoreSurfaceSetPalette *args = (CoreSurfaceSetPalette*) alloca( sizeof(CoreSurfaceSetPalette) );
519 CoreSurfaceSetPaletteReturn *return_args = (CoreSurfaceSetPaletteReturn*) alloca( sizeof(CoreSurfaceSetPaletteReturn) );
520
521 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
522
523 D_ASSERT( palette != NULL );
524
525 args->palette_id = CorePalette_GetID( palette );
526
527 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_SetPalette, args, sizeof(CoreSurfaceSetPalette), return_args, sizeof(CoreSurfaceSetPaletteReturn), NULL );
528 if (ret) {
529 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_SetPalette ) failed!\n", __FUNCTION__ );
530 return ret;
531 }
532
533 if (return_args->result) {
534 /*D_DERROR( return_args->result, "%s: CoreSurface_SetPalette failed!\n", __FUNCTION__ );*/
535 return return_args->result;
536 }
537
538
539 return DFB_OK;
540 }
541
542
543 DFBResult
ISurface_Requestor__SetAlphaRamp(CoreSurface * obj,u8 a0,u8 a1,u8 a2,u8 a3)544 ISurface_Requestor__SetAlphaRamp( CoreSurface *obj,
545 u8 a0,
546 u8 a1,
547 u8 a2,
548 u8 a3
549 )
550 {
551 DFBResult ret;
552 CoreSurfaceSetAlphaRamp *args = (CoreSurfaceSetAlphaRamp*) alloca( sizeof(CoreSurfaceSetAlphaRamp) );
553 CoreSurfaceSetAlphaRampReturn *return_args = (CoreSurfaceSetAlphaRampReturn*) alloca( sizeof(CoreSurfaceSetAlphaRampReturn) );
554
555 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
556
557
558 args->a0 = a0;
559 args->a1 = a1;
560 args->a2 = a2;
561 args->a3 = a3;
562
563 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_SetAlphaRamp, args, sizeof(CoreSurfaceSetAlphaRamp), return_args, sizeof(CoreSurfaceSetAlphaRampReturn), NULL );
564 if (ret) {
565 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_SetAlphaRamp ) failed!\n", __FUNCTION__ );
566 return ret;
567 }
568
569 if (return_args->result) {
570 /*D_DERROR( return_args->result, "%s: CoreSurface_SetAlphaRamp failed!\n", __FUNCTION__ );*/
571 return return_args->result;
572 }
573
574
575 return DFB_OK;
576 }
577
578
579 DFBResult
ISurface_Requestor__SetField(CoreSurface * obj,s32 field)580 ISurface_Requestor__SetField( CoreSurface *obj,
581 s32 field
582 )
583 {
584 DFBResult ret;
585 CoreSurfaceSetField *args = (CoreSurfaceSetField*) alloca( sizeof(CoreSurfaceSetField) );
586 CoreSurfaceSetFieldReturn *return_args = (CoreSurfaceSetFieldReturn*) alloca( sizeof(CoreSurfaceSetFieldReturn) );
587
588 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
589
590
591 args->field = field;
592
593 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_SetField, args, sizeof(CoreSurfaceSetField), return_args, sizeof(CoreSurfaceSetFieldReturn), NULL );
594 if (ret) {
595 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_SetField ) failed!\n", __FUNCTION__ );
596 return ret;
597 }
598
599 if (return_args->result) {
600 /*D_DERROR( return_args->result, "%s: CoreSurface_SetField failed!\n", __FUNCTION__ );*/
601 return return_args->result;
602 }
603
604
605 return DFB_OK;
606 }
607
608
609 DFBResult
ISurface_Requestor__PreLockBuffer(CoreSurface * obj,CoreSurfaceBuffer * buffer,CoreSurfaceAccessorID accessor,CoreSurfaceAccessFlags access,CoreSurfaceAllocation ** ret_allocation)610 ISurface_Requestor__PreLockBuffer( CoreSurface *obj,
611 CoreSurfaceBuffer *buffer,
612 CoreSurfaceAccessorID accessor,
613 CoreSurfaceAccessFlags access,
614 CoreSurfaceAllocation **ret_allocation
615 )
616 {
617 DFBResult ret;
618 CoreSurfaceAllocation *allocation = NULL;
619 CoreSurfacePreLockBuffer *args = (CoreSurfacePreLockBuffer*) alloca( sizeof(CoreSurfacePreLockBuffer) );
620 CoreSurfacePreLockBufferReturn *return_args = (CoreSurfacePreLockBufferReturn*) alloca( sizeof(CoreSurfacePreLockBufferReturn) );
621
622 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
623
624 D_ASSERT( buffer != NULL );
625 D_ASSERT( ret_allocation != NULL );
626
627 args->buffer_id = CoreSurfaceBuffer_GetID( buffer );
628 args->accessor = accessor;
629 args->access = access;
630
631 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_PreLockBuffer, args, sizeof(CoreSurfacePreLockBuffer), return_args, sizeof(CoreSurfacePreLockBufferReturn), NULL );
632 if (ret) {
633 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_PreLockBuffer ) failed!\n", __FUNCTION__ );
634 return ret;
635 }
636
637 if (return_args->result) {
638 /*D_DERROR( return_args->result, "%s: CoreSurface_PreLockBuffer failed!\n", __FUNCTION__ );*/
639 return return_args->result;
640 }
641
642
643 ret = (DFBResult) CoreSurfaceAllocation_Catch( core_dfb, return_args->allocation_id, &allocation );
644 if (ret) {
645 D_DERROR( ret, "%s: Catching allocation by ID %u failed!\n", __FUNCTION__, return_args->allocation_id );
646 return ret;
647 }
648
649 *ret_allocation = allocation;
650
651 return DFB_OK;
652 }
653
654
655 DFBResult
ISurface_Requestor__PreLockBuffer2(CoreSurface * obj,CoreSurfaceBufferRole role,CoreSurfaceAccessorID accessor,CoreSurfaceAccessFlags access,bool lock,CoreSurfaceAllocation ** ret_allocation)656 ISurface_Requestor__PreLockBuffer2( CoreSurface *obj,
657 CoreSurfaceBufferRole role,
658 CoreSurfaceAccessorID accessor,
659 CoreSurfaceAccessFlags access,
660 bool lock,
661 CoreSurfaceAllocation **ret_allocation
662 )
663 {
664 DFBResult ret;
665 CoreSurfaceAllocation *allocation = NULL;
666 CoreSurfacePreLockBuffer2 *args = (CoreSurfacePreLockBuffer2*) alloca( sizeof(CoreSurfacePreLockBuffer2) );
667 CoreSurfacePreLockBuffer2Return *return_args = (CoreSurfacePreLockBuffer2Return*) alloca( sizeof(CoreSurfacePreLockBuffer2Return) );
668
669 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
670
671 D_ASSERT( ret_allocation != NULL );
672
673 args->role = role;
674 args->accessor = accessor;
675 args->access = access;
676 args->lock = lock;
677
678 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_PreLockBuffer2, args, sizeof(CoreSurfacePreLockBuffer2), return_args, sizeof(CoreSurfacePreLockBuffer2Return), NULL );
679 if (ret) {
680 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_PreLockBuffer2 ) failed!\n", __FUNCTION__ );
681 return ret;
682 }
683
684 if (return_args->result) {
685 /*D_DERROR( return_args->result, "%s: CoreSurface_PreLockBuffer2 failed!\n", __FUNCTION__ );*/
686 return return_args->result;
687 }
688
689
690 ret = (DFBResult) CoreSurfaceAllocation_Catch( core_dfb, return_args->allocation_id, &allocation );
691 if (ret) {
692 D_DERROR( ret, "%s: Catching allocation by ID %u failed!\n", __FUNCTION__, return_args->allocation_id );
693 return ret;
694 }
695
696 *ret_allocation = allocation;
697
698 return DFB_OK;
699 }
700
701
702 DFBResult
ISurface_Requestor__PreReadBuffer(CoreSurface * obj,CoreSurfaceBuffer * buffer,const DFBRectangle * rect,CoreSurfaceAllocation ** ret_allocation)703 ISurface_Requestor__PreReadBuffer( CoreSurface *obj,
704 CoreSurfaceBuffer *buffer,
705 const DFBRectangle *rect,
706 CoreSurfaceAllocation **ret_allocation
707 )
708 {
709 DFBResult ret;
710 CoreSurfaceAllocation *allocation = NULL;
711 CoreSurfacePreReadBuffer *args = (CoreSurfacePreReadBuffer*) alloca( sizeof(CoreSurfacePreReadBuffer) );
712 CoreSurfacePreReadBufferReturn *return_args = (CoreSurfacePreReadBufferReturn*) alloca( sizeof(CoreSurfacePreReadBufferReturn) );
713
714 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
715
716 D_ASSERT( buffer != NULL );
717 D_ASSERT( rect != NULL );
718 D_ASSERT( ret_allocation != NULL );
719
720 args->buffer_id = CoreSurfaceBuffer_GetID( buffer );
721 args->rect = *rect;
722
723 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_PreReadBuffer, args, sizeof(CoreSurfacePreReadBuffer), return_args, sizeof(CoreSurfacePreReadBufferReturn), NULL );
724 if (ret) {
725 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_PreReadBuffer ) failed!\n", __FUNCTION__ );
726 return ret;
727 }
728
729 if (return_args->result) {
730 /*D_DERROR( return_args->result, "%s: CoreSurface_PreReadBuffer failed!\n", __FUNCTION__ );*/
731 return return_args->result;
732 }
733
734
735 ret = (DFBResult) CoreSurfaceAllocation_Catch( core_dfb, return_args->allocation_id, &allocation );
736 if (ret) {
737 D_DERROR( ret, "%s: Catching allocation by ID %u failed!\n", __FUNCTION__, return_args->allocation_id );
738 return ret;
739 }
740
741 *ret_allocation = allocation;
742
743 return DFB_OK;
744 }
745
746
747 DFBResult
ISurface_Requestor__PreWriteBuffer(CoreSurface * obj,CoreSurfaceBuffer * buffer,const DFBRectangle * rect,CoreSurfaceAllocation ** ret_allocation)748 ISurface_Requestor__PreWriteBuffer( CoreSurface *obj,
749 CoreSurfaceBuffer *buffer,
750 const DFBRectangle *rect,
751 CoreSurfaceAllocation **ret_allocation
752 )
753 {
754 DFBResult ret;
755 CoreSurfaceAllocation *allocation = NULL;
756 CoreSurfacePreWriteBuffer *args = (CoreSurfacePreWriteBuffer*) alloca( sizeof(CoreSurfacePreWriteBuffer) );
757 CoreSurfacePreWriteBufferReturn *return_args = (CoreSurfacePreWriteBufferReturn*) alloca( sizeof(CoreSurfacePreWriteBufferReturn) );
758
759 D_DEBUG_AT( DirectFB_CoreSurface, "ISurface_Requestor::%s()\n", __FUNCTION__ );
760
761 D_ASSERT( buffer != NULL );
762 D_ASSERT( rect != NULL );
763 D_ASSERT( ret_allocation != NULL );
764
765 args->buffer_id = CoreSurfaceBuffer_GetID( buffer );
766 args->rect = *rect;
767
768 ret = (DFBResult) CoreSurface_Call( obj, FCEF_NONE, _CoreSurface_PreWriteBuffer, args, sizeof(CoreSurfacePreWriteBuffer), return_args, sizeof(CoreSurfacePreWriteBufferReturn), NULL );
769 if (ret) {
770 D_DERROR( ret, "%s: CoreSurface_Call( CoreSurface_PreWriteBuffer ) failed!\n", __FUNCTION__ );
771 return ret;
772 }
773
774 if (return_args->result) {
775 /*D_DERROR( return_args->result, "%s: CoreSurface_PreWriteBuffer failed!\n", __FUNCTION__ );*/
776 return return_args->result;
777 }
778
779
780 ret = (DFBResult) CoreSurfaceAllocation_Catch( core_dfb, return_args->allocation_id, &allocation );
781 if (ret) {
782 D_DERROR( ret, "%s: Catching allocation by ID %u failed!\n", __FUNCTION__, return_args->allocation_id );
783 return ret;
784 }
785
786 *ret_allocation = allocation;
787
788 return DFB_OK;
789 }
790
791 /*********************************************************************************************************************/
792
793 static DFBResult
__CoreSurfaceDispatch__Dispatch(CoreSurface * obj,FusionID caller,int method,void * ptr,unsigned int length,void * ret_ptr,unsigned int ret_size,unsigned int * ret_length)794 __CoreSurfaceDispatch__Dispatch( CoreSurface *obj,
795 FusionID caller,
796 int method,
797 void *ptr,
798 unsigned int length,
799 void *ret_ptr,
800 unsigned int ret_size,
801 unsigned int *ret_length )
802 {
803 D_UNUSED
804 DFBResult ret;
805
806
807 switch (method) {
808 case _CoreSurface_SetConfig: {
809 D_UNUSED
810 CoreSurfaceSetConfig *args = (CoreSurfaceSetConfig *) ptr;
811 CoreSurfaceSetConfigReturn *return_args = (CoreSurfaceSetConfigReturn *) ret_ptr;
812
813 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_SetConfig\n" );
814
815 return_args->result = ISurface_Real__SetConfig( obj, &args->config );
816 if (return_args->result == DFB_OK) {
817 }
818
819 *ret_length = sizeof(CoreSurfaceSetConfigReturn);
820
821 return DFB_OK;
822 }
823
824 case _CoreSurface_Flip: {
825 D_UNUSED
826 CoreSurfaceFlip *args = (CoreSurfaceFlip *) ptr;
827 CoreSurfaceFlipReturn *return_args = (CoreSurfaceFlipReturn *) ret_ptr;
828
829 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_Flip\n" );
830
831 return_args->result = ISurface_Real__Flip( obj, args->swap );
832 if (return_args->result == DFB_OK) {
833 }
834
835 *ret_length = sizeof(CoreSurfaceFlipReturn);
836
837 return DFB_OK;
838 }
839
840 case _CoreSurface_GetPalette: {
841 CorePalette *palette = NULL;
842 D_UNUSED
843 CoreSurfaceGetPalette *args = (CoreSurfaceGetPalette *) ptr;
844 CoreSurfaceGetPaletteReturn *return_args = (CoreSurfaceGetPaletteReturn *) ret_ptr;
845
846 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_GetPalette\n" );
847
848 return_args->result = ISurface_Real__GetPalette( obj, &palette );
849 if (return_args->result == DFB_OK) {
850 CorePalette_Throw( palette, caller, &return_args->palette_id );
851 }
852
853 *ret_length = sizeof(CoreSurfaceGetPaletteReturn);
854
855 return DFB_OK;
856 }
857
858 case _CoreSurface_SetPalette: {
859 CorePalette *palette = NULL;
860 D_UNUSED
861 CoreSurfaceSetPalette *args = (CoreSurfaceSetPalette *) ptr;
862 CoreSurfaceSetPaletteReturn *return_args = (CoreSurfaceSetPaletteReturn *) ret_ptr;
863
864 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_SetPalette\n" );
865
866 ret = (DFBResult) CorePalette_Lookup( core_dfb, args->palette_id, caller, &palette );
867 if (ret) {
868 D_DERROR( ret, "%s: Looking up palette by ID %u failed!\n", __FUNCTION__, args->palette_id );
869 return_args->result = ret;
870 return DFB_OK;
871 }
872
873 return_args->result = ISurface_Real__SetPalette( obj, palette );
874 if (return_args->result == DFB_OK) {
875 }
876
877 *ret_length = sizeof(CoreSurfaceSetPaletteReturn);
878
879 if (palette)
880 CorePalette_Unref( palette );
881
882 return DFB_OK;
883 }
884
885 case _CoreSurface_SetAlphaRamp: {
886 D_UNUSED
887 CoreSurfaceSetAlphaRamp *args = (CoreSurfaceSetAlphaRamp *) ptr;
888 CoreSurfaceSetAlphaRampReturn *return_args = (CoreSurfaceSetAlphaRampReturn *) ret_ptr;
889
890 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_SetAlphaRamp\n" );
891
892 return_args->result = ISurface_Real__SetAlphaRamp( obj, args->a0, args->a1, args->a2, args->a3 );
893 if (return_args->result == DFB_OK) {
894 }
895
896 *ret_length = sizeof(CoreSurfaceSetAlphaRampReturn);
897
898 return DFB_OK;
899 }
900
901 case _CoreSurface_SetField: {
902 D_UNUSED
903 CoreSurfaceSetField *args = (CoreSurfaceSetField *) ptr;
904 CoreSurfaceSetFieldReturn *return_args = (CoreSurfaceSetFieldReturn *) ret_ptr;
905
906 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_SetField\n" );
907
908 return_args->result = ISurface_Real__SetField( obj, args->field );
909 if (return_args->result == DFB_OK) {
910 }
911
912 *ret_length = sizeof(CoreSurfaceSetFieldReturn);
913
914 return DFB_OK;
915 }
916
917 case _CoreSurface_PreLockBuffer: {
918 CoreSurfaceBuffer *buffer = NULL;
919 CoreSurfaceAllocation *allocation = NULL;
920 D_UNUSED
921 CoreSurfacePreLockBuffer *args = (CoreSurfacePreLockBuffer *) ptr;
922 CoreSurfacePreLockBufferReturn *return_args = (CoreSurfacePreLockBufferReturn *) ret_ptr;
923
924 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_PreLockBuffer\n" );
925
926 ret = (DFBResult) CoreSurfaceBuffer_Lookup( core_dfb, args->buffer_id, caller, &buffer );
927 if (ret) {
928 D_DERROR( ret, "%s: Looking up buffer by ID %u failed!\n", __FUNCTION__, args->buffer_id );
929 return_args->result = ret;
930 return DFB_OK;
931 }
932
933 return_args->result = ISurface_Real__PreLockBuffer( obj, buffer, args->accessor, args->access, &allocation );
934 if (return_args->result == DFB_OK) {
935 CoreSurfaceAllocation_Throw( allocation, caller, &return_args->allocation_id );
936 }
937
938 *ret_length = sizeof(CoreSurfacePreLockBufferReturn);
939
940 if (buffer)
941 CoreSurfaceBuffer_Unref( buffer );
942
943 return DFB_OK;
944 }
945
946 case _CoreSurface_PreLockBuffer2: {
947 CoreSurfaceAllocation *allocation = NULL;
948 D_UNUSED
949 CoreSurfacePreLockBuffer2 *args = (CoreSurfacePreLockBuffer2 *) ptr;
950 CoreSurfacePreLockBuffer2Return *return_args = (CoreSurfacePreLockBuffer2Return *) ret_ptr;
951
952 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_PreLockBuffer2\n" );
953
954 return_args->result = ISurface_Real__PreLockBuffer2( obj, args->role, args->accessor, args->access, args->lock, &allocation );
955 if (return_args->result == DFB_OK) {
956 CoreSurfaceAllocation_Throw( allocation, caller, &return_args->allocation_id );
957 }
958
959 *ret_length = sizeof(CoreSurfacePreLockBuffer2Return);
960
961 return DFB_OK;
962 }
963
964 case _CoreSurface_PreReadBuffer: {
965 CoreSurfaceBuffer *buffer = NULL;
966 CoreSurfaceAllocation *allocation = NULL;
967 D_UNUSED
968 CoreSurfacePreReadBuffer *args = (CoreSurfacePreReadBuffer *) ptr;
969 CoreSurfacePreReadBufferReturn *return_args = (CoreSurfacePreReadBufferReturn *) ret_ptr;
970
971 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_PreReadBuffer\n" );
972
973 ret = (DFBResult) CoreSurfaceBuffer_Lookup( core_dfb, args->buffer_id, caller, &buffer );
974 if (ret) {
975 D_DERROR( ret, "%s: Looking up buffer by ID %u failed!\n", __FUNCTION__, args->buffer_id );
976 return_args->result = ret;
977 return DFB_OK;
978 }
979
980 return_args->result = ISurface_Real__PreReadBuffer( obj, buffer, &args->rect, &allocation );
981 if (return_args->result == DFB_OK) {
982 CoreSurfaceAllocation_Throw( allocation, caller, &return_args->allocation_id );
983 }
984
985 *ret_length = sizeof(CoreSurfacePreReadBufferReturn);
986
987 if (buffer)
988 CoreSurfaceBuffer_Unref( buffer );
989
990 return DFB_OK;
991 }
992
993 case _CoreSurface_PreWriteBuffer: {
994 CoreSurfaceBuffer *buffer = NULL;
995 CoreSurfaceAllocation *allocation = NULL;
996 D_UNUSED
997 CoreSurfacePreWriteBuffer *args = (CoreSurfacePreWriteBuffer *) ptr;
998 CoreSurfacePreWriteBufferReturn *return_args = (CoreSurfacePreWriteBufferReturn *) ret_ptr;
999
1000 D_DEBUG_AT( DirectFB_CoreSurface, "=-> CoreSurface_PreWriteBuffer\n" );
1001
1002 ret = (DFBResult) CoreSurfaceBuffer_Lookup( core_dfb, args->buffer_id, caller, &buffer );
1003 if (ret) {
1004 D_DERROR( ret, "%s: Looking up buffer by ID %u failed!\n", __FUNCTION__, args->buffer_id );
1005 return_args->result = ret;
1006 return DFB_OK;
1007 }
1008
1009 return_args->result = ISurface_Real__PreWriteBuffer( obj, buffer, &args->rect, &allocation );
1010 if (return_args->result == DFB_OK) {
1011 CoreSurfaceAllocation_Throw( allocation, caller, &return_args->allocation_id );
1012 }
1013
1014 *ret_length = sizeof(CoreSurfacePreWriteBufferReturn);
1015
1016 if (buffer)
1017 CoreSurfaceBuffer_Unref( buffer );
1018
1019 return DFB_OK;
1020 }
1021
1022 }
1023
1024 return DFB_NOSUCHMETHOD;
1025 }
1026 /*********************************************************************************************************************/
1027
1028 DFBResult
CoreSurfaceDispatch__Dispatch(CoreSurface * obj,FusionID caller,int method,void * ptr,unsigned int length,void * ret_ptr,unsigned int ret_size,unsigned int * ret_length)1029 CoreSurfaceDispatch__Dispatch( CoreSurface *obj,
1030 FusionID caller,
1031 int method,
1032 void *ptr,
1033 unsigned int length,
1034 void *ret_ptr,
1035 unsigned int ret_size,
1036 unsigned int *ret_length )
1037 {
1038 DFBResult ret;
1039
1040 D_DEBUG_AT( DirectFB_CoreSurface, "CoreSurfaceDispatch::%s( %p )\n", __FUNCTION__, obj );
1041
1042 Core_PushIdentity( caller );
1043
1044 ret = __CoreSurfaceDispatch__Dispatch( obj, caller, method, ptr, length, ret_ptr, ret_size, ret_length );
1045
1046 Core_PopIdentity();
1047
1048 return ret;
1049 }
1050