1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/graphicscomposition/openwfcompositionengine/composition/src/wfcapi.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1024 @@
1.4 +/* Copyright (c) 2009-2010 The Khronos Group Inc.
1.5 + * Portions copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies)
1.6 + *
1.7 + * Permission is hereby granted, free of charge, to any person obtaining a
1.8 + * copy of this software and/or associated documentation files (the
1.9 + * "Materials"), to deal in the Materials without restriction, including
1.10 + * without limitation the rights to use, copy, modify, merge, publish,
1.11 + * distribute, sublicense, and/or sell copies of the Materials, and to
1.12 + * permit persons to whom the Materials are furnished to do so, subject to
1.13 + * the following conditions:
1.14 + *
1.15 + * The above copyright notice and this permission notice shall be included
1.16 + * in all copies or substantial portions of the Materials.
1.17 + *
1.18 + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
1.19 + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
1.20 + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
1.21 + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
1.22 + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
1.23 + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
1.24 + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
1.25 + */
1.26 +
1.27 +/*! \ingroup wfc
1.28 + * \file wfcapi.c
1.29 + * \brief OpenWF Composition SI, API implementation.
1.30 + *
1.31 + * For function documentations, see OpenWF Composition specification 1.0
1.32 + *
1.33 + * The general layout of an API function is:
1.34 + * - grab API mutex (lock API)
1.35 + * - check parameter validity
1.36 + * - invoke implementation function (WFD_...)
1.37 + * - unlock API
1.38 + * - return
1.39 + *
1.40 + */
1.41 +
1.42 +#include <string.h>
1.43 +#include <stdio.h>
1.44 +#include <stdlib.h>
1.45 +#include <math.h>
1.46 +
1.47 +#include <WF/wfc.h>
1.48 +#include <WF/wfcext.h>
1.49 +
1.50 +#include "wfcstructs.h"
1.51 +#include "wfccontext.h"
1.52 +#include "owfnativestream.h"
1.53 +#include "owfscreen.h"
1.54 +
1.55 +#define RGB_NUM_BYTES (sizeof(WFCuint8) * 4)
1.56 +
1.57 +#define COND_FAIL(cond,error,retval) \
1.58 + if (!(cond)) { \
1.59 + WFC_Device_SetError(dev, error); \
1.60 + WFC_Unlock(); \
1.61 + return retval; \
1.62 + }
1.63 +
1.64 +#define COND_FAIL_NR(cond,error) \
1.65 + if (!(cond)) { \
1.66 + WFC_Device_SetError(dev, error); \
1.67 + WFC_Unlock(); \
1.68 + return; \
1.69 + }
1.70 +
1.71 +#define GET_DEVICE(d, h, x) \
1.72 + WFC_Lock(); \
1.73 + d = WFC_Device_FindByHandle(h); \
1.74 + if (NULL == d) { \
1.75 + WFC_Unlock(); \
1.76 + return x; \
1.77 + }
1.78 +
1.79 +#define GET_DEVICE_NR(d, h) \
1.80 + WFC_Lock(); \
1.81 + d = WFC_Device_FindByHandle(h); \
1.82 + if (WFC_INVALID_HANDLE == d) { \
1.83 + WFC_Unlock(); \
1.84 + return; \
1.85 + }
1.86 +
1.87 +#define GET_CONTEXT_NR(c,d,h) \
1.88 + c = WFC_Device_FindContext(d, h); \
1.89 + if (WFC_INVALID_HANDLE == c) { \
1.90 + WFC_Device_SetError((d)->handle, WFC_ERROR_BAD_HANDLE); \
1.91 + WFC_Unlock(); \
1.92 + return; \
1.93 + }
1.94 +
1.95 +#define GET_CONTEXT(c,d,h,x) \
1.96 + c = WFC_Device_FindContext(d, h); \
1.97 + if (WFC_INVALID_HANDLE == c) { \
1.98 + WFC_Device_SetError((d)->handle, WFC_ERROR_BAD_HANDLE); \
1.99 + WFC_Unlock(); \
1.100 + return x; \
1.101 + }
1.102 +
1.103 +#define SUCCEED(retval) \
1.104 + WFC_Device_SetError(dev, WFC_ERROR_NONE); \
1.105 + WFC_Unlock(); \
1.106 + return retval
1.107 +
1.108 +#define SUCCEED_NR() \
1.109 + WFC_Device_SetError(dev, WFC_ERROR_NONE); \
1.110 + WFC_Unlock(); \
1.111 + return
1.112 +
1.113 +#define FAIL(err, retval) \
1.114 + WFC_Device_SetError(dev, err); \
1.115 + WFC_Unlock(); \
1.116 + return retval
1.117 +
1.118 +#define FAIL_NR(err) \
1.119 + WFC_Device_SetError(dev, err); \
1.120 + WFC_Unlock(); \
1.121 + return
1.122 +
1.123 +
1.124 +static OWF_MUTEX mutex;
1.125 +
1.126 +static void WFC_Cleanup()
1.127 +{
1.128 + OWF_Mutex_Destroy(&mutex);
1.129 +}
1.130 +
1.131 +static void WFC_Lock()
1.132 +{
1.133 + if (!mutex)
1.134 + {
1.135 + OWF_Mutex_Init(&mutex);
1.136 + xatexit(WFC_Cleanup); // Use adaptation version of atexit
1.137 + }
1.138 + OWF_Mutex_Lock(&mutex);
1.139 +}
1.140 +
1.141 +static void WFC_Unlock()
1.142 +{
1.143 + OWF_Mutex_Unlock(&mutex);
1.144 +}
1.145 +
1.146 +/*=========================================================================*/
1.147 +/* 4. DEVICE */
1.148 +/*=========================================================================*/
1.149 +
1.150 +WFC_API_CALL WFCint WFC_APIENTRY
1.151 +wfcEnumerateDevices(WFCint *deviceIds,
1.152 + WFCint deviceIdsCount,
1.153 + const WFCint *filterList)
1.154 +{
1.155 + WFCint n;
1.156 +
1.157 + /* populate list with device IDs */
1.158 + n = WFC_Devices_GetIds(deviceIds, deviceIdsCount, filterList);
1.159 + return n;
1.160 +}
1.161 +
1.162 +WFC_API_CALL WFCDevice WFC_APIENTRY
1.163 +wfcCreateDevice(WFCint deviceId, const WFCint *attribList)
1.164 +{
1.165 + WFCDevice device;
1.166 +
1.167 + /* currently only empty attribute list or NULL is allowed */
1.168 + if (attribList && *attribList != WFC_NONE)
1.169 + {
1.170 +
1.171 + return WFC_INVALID_HANDLE;
1.172 + }
1.173 + WFC_Lock();
1.174 + device = WFC_Device_Create(deviceId);
1.175 + WFC_Unlock();
1.176 +
1.177 + return device;
1.178 +}
1.179 +
1.180 +WFC_API_CALL WFCErrorCode WFC_APIENTRY
1.181 +wfcDestroyDevice(WFCDevice dev)
1.182 +{
1.183 + WFC_DEVICE* device;
1.184 + WFCErrorCode result = WFC_ERROR_BAD_DEVICE;
1.185 +
1.186 + DPRINT(("wfcDestroyDevice(%d)", dev));
1.187 +
1.188 + WFC_Lock();
1.189 + device = WFC_Device_FindByHandle(dev);
1.190 + if (device)
1.191 + {
1.192 + WFC_Device_Destroy(device);
1.193 + result = WFC_ERROR_NONE;
1.194 + }
1.195 + WFC_Unlock();
1.196 + return result;
1.197 +}
1.198 +
1.199 +WFC_API_CALL WFCint WFC_APIENTRY
1.200 +wfcGetDeviceAttribi(WFCDevice dev,
1.201 + WFCDeviceAttrib attrib)
1.202 +{
1.203 + WFC_DEVICE* device;
1.204 + WFCint result = 0;
1.205 + WFCErrorCode err;
1.206 +
1.207 + GET_DEVICE(device, dev, 0);
1.208 + err = WFC_Device_GetAttribi(device, attrib, &result);
1.209 +
1.210 + FAIL(err, result);
1.211 +}
1.212 +
1.213 +WFC_API_CALL WFCErrorCode WFC_APIENTRY
1.214 +wfcGetError(WFCDevice dev)
1.215 +{
1.216 + WFC_DEVICE* device;
1.217 + WFCErrorCode err;
1.218 +
1.219 + GET_DEVICE(device, dev, WFC_ERROR_BAD_DEVICE);
1.220 +
1.221 + err = WFC_Device_GetError(device);
1.222 + WFC_Unlock();
1.223 + return err;
1.224 +}
1.225 +
1.226 +WFC_API_CALL void WFC_APIENTRY
1.227 +wfcCommit(WFCDevice dev, WFCContext ctx, WFCboolean wait)
1.228 +{
1.229 + WFC_DEVICE* device;
1.230 + WFC_CONTEXT* context;
1.231 + WFCErrorCode error;
1.232 +
1.233 + DPRINT(("wfcCommit(%d,%d,%d)", dev, ctx, wait));
1.234 + GET_DEVICE_NR(device, dev);
1.235 + GET_CONTEXT_NR(context, device, ctx);
1.236 +
1.237 + error = WFC_Context_InvokeCommit(device, context, wait);
1.238 +
1.239 + FAIL_NR(error);
1.240 +}
1.241 +
1.242 +/*=========================================================================*/
1.243 +/* 5. CONTEXT */
1.244 +/*=========================================================================*/
1.245 +
1.246 +WFC_API_CALL WFCContext WFC_APIENTRY
1.247 +wfcCreateOnScreenContext(WFCDevice dev,
1.248 + WFCint screenNumber,
1.249 + const WFCint* attribList)
1.250 +{
1.251 + WFC_CONTEXT* context = NULL;
1.252 + WFC_DEVICE* device = NULL;
1.253 +
1.254 + GET_DEVICE(device, dev, WFC_INVALID_HANDLE);
1.255 +
1.256 + /* currently only empty attribute list or NULL is allowed */
1.257 + COND_FAIL(!(attribList && *attribList != WFC_NONE),
1.258 + WFC_ERROR_BAD_ATTRIBUTE,
1.259 + WFC_INVALID_HANDLE);
1.260 +
1.261 + if (screenNumber == WFC_DEFAULT_SCREEN_NUMBER)
1.262 + {
1.263 + screenNumber = OWF_Screen_GetDefaultNumber();
1.264 + }
1.265 +
1.266 + /* check screen number validity */
1.267 + if (!OWF_Screen_Valid(screenNumber))
1.268 + {
1.269 + FAIL(WFC_ERROR_UNSUPPORTED, WFC_INVALID_HANDLE);
1.270 + }
1.271 +
1.272 + /* check that no other context currently uses this screen */
1.273 + if (WFC_Device_FindScreenNumber(screenNumber))
1.274 + {
1.275 + FAIL(WFC_ERROR_IN_USE, WFC_INVALID_HANDLE);
1.276 + }
1.277 +
1.278 +
1.279 + context = WFC_Device_CreateContext(device,
1.280 + WFC_INVALID_HANDLE,
1.281 + WFC_CONTEXT_TYPE_ON_SCREEN,
1.282 + screenNumber);
1.283 + if (!context)
1.284 + {
1.285 + FAIL(WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);
1.286 + }
1.287 +
1.288 + SUCCEED(context->handle);
1.289 +}
1.290 +
1.291 +WFC_API_CALL WFCContext WFC_APIENTRY
1.292 +wfcCreateOffScreenContext(WFCDevice dev,
1.293 + WFCNativeStreamType stream,
1.294 + const WFCint *attribList)
1.295 +{
1.296 + WFC_CONTEXT* context = NULL;
1.297 + WFC_DEVICE* device = NULL;
1.298 + OWFNativeStreamType internalStream=OWF_INVALID_HANDLE;
1.299 + OWF_STREAM_ERROR streamError;
1.300 +
1.301 + GET_DEVICE(device, dev, WFC_INVALID_HANDLE);
1.302 +
1.303 + /* currently only empty attribute list or NULL is allowed */
1.304 + COND_FAIL(!(attribList && *attribList != WFC_NONE),
1.305 + WFC_ERROR_BAD_ATTRIBUTE,
1.306 + WFC_INVALID_HANDLE);
1.307 +
1.308 + COND_FAIL(OWF_INVALID_HANDLE != (OWFNativeStreamType) stream,
1.309 + WFC_ERROR_ILLEGAL_ARGUMENT,
1.310 + WFC_INVALID_HANDLE);
1.311 + internalStream=owfNativeStreamFromWFC(stream,&streamError);
1.312 + COND_FAIL(OWF_STREAM_ERROR_INVALID_STREAM!=streamError,WFC_ERROR_UNSUPPORTED,WFC_INVALID_HANDLE);
1.313 + COND_FAIL(OWF_STREAM_ERROR_OUT_OF_MEMORY!=streamError,WFC_ERROR_OUT_OF_MEMORY,WFC_INVALID_HANDLE);
1.314 +
1.315 + if (!WFC_Context_IsValidTargetStream(internalStream))
1.316 + {
1.317 + owfNativeStreamDestroy(internalStream); /*cancel owfNativeStreamFromWFC reference increase*/
1.318 + FAIL(WFC_ERROR_UNSUPPORTED,WFC_INVALID_HANDLE);
1.319 + }
1.320 + context = WFC_Device_CreateContext(device, internalStream,
1.321 + WFC_CONTEXT_TYPE_OFF_SCREEN,
1.322 + OWF_RESERVED_BAD_SCREEN_NUMBER);
1.323 + owfNativeStreamDestroy(internalStream); /*cancel owfNativeStreamFromWFC reference increase*/
1.324 + COND_FAIL(NULL != context, WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);
1.325 +
1.326 + SUCCEED(context->handle);
1.327 +}
1.328 +
1.329 +WFC_API_CALL void WFC_APIENTRY
1.330 +wfcDestroyContext(WFCDevice dev,
1.331 + WFCContext ctx)
1.332 +{
1.333 + WFC_DEVICE* device = NULL;
1.334 + WFCErrorCode err;
1.335 +
1.336 + DPRINT(("wfcDestroyContext(%d, %d)", dev, ctx));
1.337 + GET_DEVICE_NR(device, dev);
1.338 +
1.339 + err = WFC_Device_DestroyContext(device, ctx);
1.340 + FAIL_NR(err);
1.341 +}
1.342 +
1.343 +WFC_API_CALL WFCint WFC_APIENTRY
1.344 +wfcGetContextAttribi(WFCDevice dev,
1.345 + WFCContext ctx,
1.346 + WFCContextAttrib attrib)
1.347 +{
1.348 + WFC_CONTEXT* context = NULL;
1.349 + WFC_DEVICE* device = NULL;
1.350 + WFCint value = 0;
1.351 + WFCErrorCode err;
1.352 +
1.353 + GET_DEVICE(device, dev, 0);
1.354 + GET_CONTEXT(context, device, ctx, 0);
1.355 +
1.356 + err = WFC_Context_GetAttribi(context, attrib, &value);
1.357 +
1.358 + FAIL(err, value);
1.359 +}
1.360 +
1.361 +WFC_API_CALL void WFC_APIENTRY
1.362 +wfcSetContextAttribi(WFCDevice dev,
1.363 + WFCContext ctx,
1.364 + WFCContextAttrib attrib,
1.365 + WFCint value)
1.366 +{
1.367 + WFC_DEVICE* device;
1.368 + WFC_CONTEXT* context;
1.369 + WFCErrorCode err;
1.370 +
1.371 + GET_DEVICE_NR(device, dev);
1.372 + GET_CONTEXT_NR(context, device, ctx);
1.373 +
1.374 + err = WFC_Context_SetAttribi(context, attrib, value);
1.375 + FAIL_NR(err);
1.376 +}
1.377 +
1.378 +WFC_API_CALL void WFC_APIENTRY
1.379 +wfcGetContextAttribfv(WFCDevice dev,
1.380 + WFCContext ctx,
1.381 + WFCContextAttrib attrib,
1.382 + WFCint count,
1.383 + WFCfloat *values) WFC_APIEXIT
1.384 +{
1.385 + WFC_DEVICE* device;
1.386 + WFC_CONTEXT* context;
1.387 + WFCErrorCode err;
1.388 +
1.389 + GET_DEVICE_NR(device, dev);
1.390 + GET_CONTEXT_NR(context, device, ctx);
1.391 +
1.392 + err = WFC_Context_GetAttribfv(context, attrib, count, values);
1.393 + FAIL_NR(err);
1.394 +}
1.395 +
1.396 +WFC_API_CALL void WFC_APIENTRY
1.397 +wfcSetContextAttribfv(WFCDevice dev,
1.398 + WFCContext ctx,
1.399 + WFCContextAttrib attrib,
1.400 + WFCint count,
1.401 + const WFCfloat *values) WFC_APIEXIT
1.402 +{
1.403 + WFC_DEVICE* device;
1.404 + WFC_CONTEXT* context;
1.405 + WFCErrorCode err;
1.406 +
1.407 + GET_DEVICE_NR(device, dev);
1.408 + GET_CONTEXT_NR(context, device, ctx);
1.409 +
1.410 + err = WFC_Context_SetAttribfv(context, attrib, count, values);
1.411 + FAIL_NR(err);
1.412 +}
1.413 +
1.414 +/*=========================================================================*/
1.415 +/* 6. IMAGE PROVIDERS (SOURCES & MASKS) */
1.416 +/*=========================================================================*/
1.417 +
1.418 +WFC_API_CALL WFCSource WFC_APIENTRY
1.419 +wfcCreateSourceFromStream(WFCDevice dev,
1.420 + WFCContext ctx,
1.421 + WFCNativeStreamType stream,
1.422 + const WFCint *attribList)
1.423 +{
1.424 + WFC_DEVICE* device;
1.425 + WFC_IMAGE_PROVIDER* source;
1.426 + WFC_CONTEXT* context;
1.427 + OWFNativeStreamType internalStream=OWF_INVALID_HANDLE;
1.428 + OWF_STREAM_ERROR streamError;
1.429 +
1.430 + GET_DEVICE(device, dev, WFC_INVALID_HANDLE);
1.431 +
1.432 + /* currently only empty attribute list or NULL is allowed */
1.433 + COND_FAIL(!(attribList && *attribList != WFC_NONE),
1.434 + WFC_ERROR_BAD_ATTRIBUTE,
1.435 + WFC_INVALID_HANDLE);
1.436 +
1.437 + GET_CONTEXT(context, device, ctx, WFC_INVALID_HANDLE);
1.438 + COND_FAIL(OWF_INVALID_HANDLE != (OWFNativeStreamType) stream,
1.439 + WFC_ERROR_ILLEGAL_ARGUMENT,
1.440 + WFC_INVALID_HANDLE);
1.441 +
1.442 + internalStream=owfNativeStreamFromWFC(stream,&streamError);
1.443 + COND_FAIL(OWF_STREAM_ERROR_INVALID_STREAM!=streamError,WFC_ERROR_UNSUPPORTED,WFC_INVALID_HANDLE);
1.444 + COND_FAIL(OWF_STREAM_ERROR_OUT_OF_MEMORY!=streamError,WFC_ERROR_OUT_OF_MEMORY,WFC_INVALID_HANDLE);
1.445 +
1.446 + if (context->stream == internalStream)
1.447 + {
1.448 + owfNativeStreamDestroy(internalStream);
1.449 + FAIL( WFC_ERROR_IN_USE, WFC_INVALID_HANDLE);
1.450 + }
1.451 +
1.452 + if (!WFC_Context_IsValidSourceStream(internalStream))
1.453 + {
1.454 + owfNativeStreamDestroy(internalStream);
1.455 + FAIL( WFC_ERROR_UNSUPPORTED, WFC_INVALID_HANDLE);
1.456 + }
1.457 +
1.458 + source = WFC_Device_CreateSource(device, context, internalStream);
1.459 + owfNativeStreamDestroy(internalStream); /*cancel FromWFC reference increase*/
1.460 + COND_FAIL(NULL != source, WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);
1.461 +
1.462 + SUCCEED(source->handle);
1.463 +}
1.464 +
1.465 +WFC_API_CALL void WFC_APIENTRY
1.466 +wfcDestroySource(WFCDevice dev,
1.467 + WFCSource src)
1.468 +{
1.469 + WFC_DEVICE* device;
1.470 + WFCErrorCode err;
1.471 +
1.472 + GET_DEVICE_NR(device, dev);
1.473 +
1.474 + err = WFC_Device_DestroySource(device, src);
1.475 +
1.476 + FAIL_NR(err);
1.477 +}
1.478 +
1.479 +WFC_API_CALL WFCMask WFC_APIENTRY
1.480 +wfcCreateMaskFromStream(WFCDevice dev,
1.481 + WFCContext ctx,
1.482 + WFCNativeStreamType stream,
1.483 + const WFCint *attribList) WFC_APIEXIT
1.484 +{
1.485 + WFC_DEVICE* device;
1.486 + WFC_CONTEXT* context;
1.487 + WFC_IMAGE_PROVIDER* mask;
1.488 + WFCboolean inUse;
1.489 + OWFNativeStreamType internalStream=OWF_INVALID_HANDLE;
1.490 + OWF_STREAM_ERROR streamError;
1.491 +
1.492 +
1.493 + GET_DEVICE(device, dev, WFC_ERROR_BAD_DEVICE);
1.494 +
1.495 + /* currently only empty attribute list or NULL is allowed */
1.496 + COND_FAIL(!(attribList && *attribList != WFC_NONE),
1.497 + WFC_ERROR_BAD_ATTRIBUTE,
1.498 + WFC_INVALID_HANDLE);
1.499 +
1.500 + GET_CONTEXT(context, device, ctx, WFC_INVALID_HANDLE);
1.501 + COND_FAIL(OWF_INVALID_HANDLE != (OWFNativeStreamType) stream,
1.502 + WFC_ERROR_ILLEGAL_ARGUMENT,
1.503 + WFC_INVALID_HANDLE);
1.504 +
1.505 + internalStream=owfNativeStreamFromWFC(stream,&streamError);
1.506 + COND_FAIL(OWF_STREAM_ERROR_INVALID_STREAM!=streamError,WFC_ERROR_UNSUPPORTED,WFC_INVALID_HANDLE);
1.507 + COND_FAIL(OWF_STREAM_ERROR_OUT_OF_MEMORY!=streamError,WFC_ERROR_OUT_OF_MEMORY,WFC_INVALID_HANDLE);
1.508 +
1.509 + inUse = WFC_Device_StreamIsTarget(device, internalStream);
1.510 + if (inUse)
1.511 + {
1.512 + owfNativeStreamDestroy(internalStream);
1.513 + FAIL( WFC_ERROR_IN_USE, WFC_INVALID_HANDLE);
1.514 + }
1.515 +
1.516 + mask = WFC_Device_CreateMask(device, context, internalStream);
1.517 + owfNativeStreamDestroy(internalStream); /*cancel FromWFC reference increase*/
1.518 + COND_FAIL(NULL != mask, WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);
1.519 +
1.520 + SUCCEED(mask->handle);
1.521 +}
1.522 +
1.523 +WFC_API_CALL void WFC_APIENTRY
1.524 +wfcDestroyMask(WFCDevice dev,
1.525 + WFCMask mask) WFC_APIEXIT
1.526 +{
1.527 + WFC_DEVICE* device;
1.528 + WFCErrorCode error;
1.529 +
1.530 + GET_DEVICE_NR(device, dev);
1.531 +
1.532 + error = WFC_Device_DestroyMask(device, mask);
1.533 +
1.534 + FAIL_NR(error);
1.535 +}
1.536 +
1.537 +/*=========================================================================*/
1.538 +/* 7. COMPOSITION ELEMENTS */
1.539 +/*=========================================================================*/
1.540 +
1.541 +WFC_API_CALL WFCElement WFC_APIENTRY
1.542 +wfcCreateElement(WFCDevice dev,
1.543 + WFCContext ctx,
1.544 + const WFCint* attribList) WFC_APIEXIT
1.545 +{
1.546 + WFC_DEVICE* device;
1.547 + WFC_ELEMENT* element;
1.548 + WFC_CONTEXT* context;
1.549 +
1.550 + GET_DEVICE(device, dev, WFC_INVALID_HANDLE);
1.551 +
1.552 + /* currently only empty attribute list or NULL is allowed */
1.553 + COND_FAIL(!(attribList && *attribList != WFC_NONE),
1.554 + WFC_ERROR_BAD_ATTRIBUTE,
1.555 + WFC_INVALID_HANDLE);
1.556 +
1.557 + GET_CONTEXT(context, device, ctx, WFC_INVALID_HANDLE);
1.558 +
1.559 + element = WFC_Device_CreateElement(device, context);
1.560 + COND_FAIL(NULL != element, WFC_ERROR_OUT_OF_MEMORY, WFC_INVALID_HANDLE);
1.561 +
1.562 + SUCCEED(element->handle);
1.563 +}
1.564 +
1.565 +WFC_API_CALL void WFC_APIENTRY
1.566 +wfcDestroyElement(WFCDevice dev,
1.567 + WFCElement element) WFC_APIEXIT
1.568 +{
1.569 + WFC_DEVICE* device;
1.570 + WFCErrorCode error = WFC_ERROR_BAD_HANDLE;
1.571 +
1.572 + GET_DEVICE_NR(device, dev);
1.573 +
1.574 + error = WFC_Device_DestroyElement(device, element);
1.575 +
1.576 + FAIL_NR(error);
1.577 +}
1.578 +
1.579 +#define ATTR_FUNC_PROLOGUE \
1.580 + WFCErrorCode error; \
1.581 + WFC_DEVICE* device; \
1.582 + \
1.583 + GET_DEVICE(device, dev, 0)
1.584 +
1.585 +#define ATTR_FUNC_PROLOGUE_NR \
1.586 + WFCErrorCode error; \
1.587 + WFC_DEVICE* device; \
1.588 + \
1.589 + GET_DEVICE_NR(device, dev)
1.590 +
1.591 +#define ATTR_FUNC_EPILOGUE(x) \
1.592 + FAIL(error, x)
1.593 +
1.594 +#define ATTR_FUNC_EPILOGUE_NR \
1.595 + FAIL_NR(error)
1.596 +
1.597 +WFC_API_CALL WFCint WFC_APIENTRY
1.598 +wfcGetElementAttribi(WFCDevice dev,
1.599 + WFCElement element,
1.600 + WFCElementAttrib attrib) WFC_APIEXIT
1.601 +{
1.602 + WFCint value;
1.603 +
1.604 + ATTR_FUNC_PROLOGUE;
1.605 +
1.606 + error = WFC_Device_GetElementAttribiv(device, element, attrib, 1, &value);
1.607 +
1.608 + ATTR_FUNC_EPILOGUE(value);
1.609 +}
1.610 +
1.611 +WFC_API_CALL WFCfloat WFC_APIENTRY
1.612 +wfcGetElementAttribf(WFCDevice dev,
1.613 + WFCElement element,
1.614 + WFCElementAttrib attrib) WFC_APIEXIT
1.615 +{
1.616 + WFCfloat value;
1.617 +
1.618 + ATTR_FUNC_PROLOGUE;
1.619 +
1.620 + COND_FAIL(WFC_ELEMENT_GLOBAL_ALPHA == attrib,
1.621 + WFC_ERROR_BAD_ATTRIBUTE,
1.622 + 0.0f);
1.623 +
1.624 + error = WFC_Device_GetElementAttribfv(device, element, attrib, 1, &value);
1.625 +
1.626 + /* value is [0, OWF_ALPHA_MAX_VALUE], map to [0, 1] */
1.627 + value = value / OWF_ALPHA_MAX_VALUE;
1.628 +
1.629 + ATTR_FUNC_EPILOGUE(value);
1.630 +}
1.631 +
1.632 +WFC_API_CALL void WFC_APIENTRY
1.633 +wfcGetElementAttribiv(WFCDevice dev,
1.634 + WFCElement element,
1.635 + WFCElementAttrib attrib,
1.636 + WFCint count,
1.637 + WFCint *values) WFC_APIEXIT
1.638 +{
1.639 + ATTR_FUNC_PROLOGUE_NR;
1.640 +
1.641 + COND_FAIL_NR(WFC_ELEMENT_SOURCE_RECTANGLE == attrib ||
1.642 + WFC_ELEMENT_DESTINATION_RECTANGLE == attrib,
1.643 + WFC_ERROR_BAD_ATTRIBUTE);
1.644 +
1.645 + error = WFC_Device_GetElementAttribiv(device, element, attrib, count,
1.646 + values);
1.647 + ATTR_FUNC_EPILOGUE_NR;
1.648 +}
1.649 +
1.650 +WFC_API_CALL void WFC_APIENTRY
1.651 +wfcGetElementAttribfv(WFCDevice dev,
1.652 + WFCElement element,
1.653 + WFCElementAttrib attrib,
1.654 + WFCint count,
1.655 + WFCfloat *values) WFC_APIEXIT
1.656 +{
1.657 + ATTR_FUNC_PROLOGUE_NR;
1.658 +
1.659 + COND_FAIL_NR(WFC_ELEMENT_SOURCE_RECTANGLE == attrib ||
1.660 + WFC_ELEMENT_DESTINATION_RECTANGLE == attrib,
1.661 + WFC_ERROR_BAD_ATTRIBUTE);
1.662 +
1.663 + error = WFC_Device_GetElementAttribfv(device, element, attrib, count,
1.664 + values);
1.665 +
1.666 + ATTR_FUNC_EPILOGUE_NR;
1.667 +}
1.668 +
1.669 +WFC_API_CALL void WFC_APIENTRY
1.670 +wfcSetElementAttribi(WFCDevice dev,
1.671 + WFCElement element,
1.672 + WFCElementAttrib attrib,
1.673 + WFCint value) WFC_APIEXIT
1.674 +{
1.675 + ATTR_FUNC_PROLOGUE_NR;
1.676 +
1.677 + error = WFC_Device_SetElementAttribiv(device, element, attrib, 1, &value);
1.678 +
1.679 + ATTR_FUNC_EPILOGUE_NR;
1.680 +}
1.681 +
1.682 +WFC_API_CALL void WFC_APIENTRY
1.683 +wfcSetElementAttribf(WFCDevice dev,
1.684 + WFCElement element,
1.685 + WFCElementAttrib attrib,
1.686 + WFCfloat value) WFC_APIEXIT
1.687 +{
1.688 + ATTR_FUNC_PROLOGUE_NR;
1.689 +
1.690 + COND_FAIL_NR(WFC_ELEMENT_GLOBAL_ALPHA == attrib,
1.691 + WFC_ERROR_BAD_ATTRIBUTE);
1.692 +
1.693 + error = WFC_Device_SetElementAttribfv(device, element, attrib, 1, &value);
1.694 +
1.695 + ATTR_FUNC_EPILOGUE_NR;
1.696 +}
1.697 +
1.698 +WFC_API_CALL void WFC_APIENTRY
1.699 +wfcSetElementAttribiv(WFCDevice dev,
1.700 + WFCElement element,
1.701 + WFCElementAttrib attrib,
1.702 + WFCint count,
1.703 + const WFCint *values) WFC_APIEXIT
1.704 +{
1.705 + ATTR_FUNC_PROLOGUE_NR;
1.706 +
1.707 + COND_FAIL_NR(WFC_ELEMENT_SOURCE_RECTANGLE == attrib ||
1.708 + WFC_ELEMENT_DESTINATION_RECTANGLE == attrib,
1.709 + WFC_ERROR_BAD_ATTRIBUTE);
1.710 +
1.711 + error = WFC_Device_SetElementAttribiv(device, element, attrib, count,
1.712 + values);
1.713 +
1.714 + ATTR_FUNC_EPILOGUE_NR;
1.715 +}
1.716 +
1.717 +WFC_API_CALL void WFC_APIENTRY
1.718 +wfcSetElementAttribfv(WFCDevice dev,
1.719 + WFCElement element,
1.720 + WFCElementAttrib attrib,
1.721 + WFCint count,
1.722 + const WFCfloat *values) WFC_APIEXIT
1.723 +{
1.724 + ATTR_FUNC_PROLOGUE_NR;
1.725 +
1.726 + COND_FAIL_NR(WFC_ELEMENT_SOURCE_RECTANGLE == attrib ||
1.727 + WFC_ELEMENT_DESTINATION_RECTANGLE == attrib,
1.728 + WFC_ERROR_BAD_ATTRIBUTE);
1.729 +
1.730 + error = WFC_Device_SetElementAttribfv(device, element, attrib, count,
1.731 + values);
1.732 +
1.733 + ATTR_FUNC_EPILOGUE_NR;
1.734 +}
1.735 +
1.736 +WFC_API_CALL void WFC_APIENTRY
1.737 +wfcInsertElement(WFCDevice dev,
1.738 + WFCElement element,
1.739 + WFCElement subordinate) WFC_APIEXIT
1.740 +{
1.741 + WFC_DEVICE* device;
1.742 + WFC_ELEMENT* elemento;
1.743 + WFCErrorCode error;
1.744 +
1.745 + GET_DEVICE_NR(device, dev);
1.746 +
1.747 + /*
1.748 + - element is inserted immediately above subordinate
1.749 + - if subordinate is NULL, then element will go to bottom
1.750 + - both elements must be in the same scene (context)
1.751 + */
1.752 + elemento = WFC_Device_FindElement(device, element);
1.753 + COND_FAIL_NR(WFC_INVALID_HANDLE != elemento, WFC_ERROR_BAD_HANDLE);
1.754 +
1.755 + error = WFC_Context_InsertElement(CONTEXT(elemento->context),
1.756 + element,
1.757 + subordinate);
1.758 +
1.759 + FAIL_NR(error);
1.760 +}
1.761 +
1.762 +WFC_API_CALL void WFC_APIENTRY
1.763 +wfcRemoveElement(WFCDevice dev,
1.764 + WFCElement element) WFC_APIEXIT
1.765 +{
1.766 + WFC_DEVICE* device;
1.767 + WFC_ELEMENT* elemento;
1.768 + WFCErrorCode error;
1.769 +
1.770 + GET_DEVICE_NR(device, dev);
1.771 +
1.772 + elemento = WFC_Device_FindElement(device, element);
1.773 + COND_FAIL_NR(WFC_INVALID_HANDLE != elemento, WFC_ERROR_BAD_HANDLE);
1.774 +
1.775 + error = WFC_Context_RemoveElement(CONTEXT(elemento->context), element);
1.776 +
1.777 + FAIL_NR(error);
1.778 +}
1.779 +
1.780 +WFC_API_CALL WFCElement WFC_APIENTRY
1.781 +wfcGetElementAbove(WFCDevice dev, WFCElement element) WFC_APIEXIT
1.782 +{
1.783 + WFC_DEVICE* device = NULL;
1.784 + WFC_ELEMENT* elemento = NULL;
1.785 + WFCElement result = WFC_INVALID_HANDLE;
1.786 + WFCErrorCode error = WFC_ERROR_NONE;
1.787 +
1.788 + GET_DEVICE(device, dev, WFC_INVALID_HANDLE);
1.789 +
1.790 + elemento = WFC_Device_FindElement(device, element);
1.791 + COND_FAIL(WFC_INVALID_HANDLE != elemento,
1.792 + WFC_ERROR_BAD_HANDLE,
1.793 + WFC_INVALID_HANDLE);
1.794 +
1.795 + error = WFC_Context_GetElementAbove(CONTEXT(elemento->context),
1.796 + element,
1.797 + &result);
1.798 +
1.799 + FAIL(error, result);
1.800 +}
1.801 +
1.802 +WFC_API_CALL WFCElement WFC_APIENTRY
1.803 +wfcGetElementBelow(WFCDevice dev, WFCElement element) WFC_APIEXIT
1.804 +{
1.805 + WFC_DEVICE* device = NULL;
1.806 + WFC_ELEMENT* elemento = NULL;
1.807 + WFCElement result = WFC_INVALID_HANDLE;
1.808 + WFCErrorCode error = WFC_ERROR_NONE;
1.809 +
1.810 + GET_DEVICE(device, dev, WFC_INVALID_HANDLE);
1.811 +
1.812 + elemento = WFC_Device_FindElement(device, element);
1.813 + COND_FAIL(WFC_INVALID_HANDLE != elemento,
1.814 + WFC_ERROR_BAD_HANDLE,
1.815 + WFC_INVALID_HANDLE);
1.816 +
1.817 + error = WFC_Context_GetElementBelow(CONTEXT(elemento->context),
1.818 + element,
1.819 + &result);
1.820 +
1.821 + FAIL(error, result);
1.822 +}
1.823 +
1.824 +/*=========================================================================*/
1.825 +/* 8. RENDERING */
1.826 +/*=========================================================================*/
1.827 +
1.828 +WFC_API_CALL void WFC_APIENTRY
1.829 +wfcActivate(WFCDevice dev,
1.830 + WFCContext ctx) WFC_APIEXIT
1.831 +{
1.832 + WFC_DEVICE* device;
1.833 + WFC_CONTEXT* context;
1.834 +
1.835 + GET_DEVICE_NR(device, dev);
1.836 + GET_CONTEXT_NR(context, device, ctx);
1.837 +
1.838 + WFC_Context_Activate(context, WFC_TRUE);
1.839 +
1.840 + SUCCEED_NR();
1.841 +}
1.842 +
1.843 +WFC_API_CALL void WFC_APIENTRY
1.844 +wfcDeactivate(WFCDevice dev,
1.845 + WFCContext ctx) WFC_APIEXIT
1.846 +{
1.847 + WFC_DEVICE* device;
1.848 + WFC_CONTEXT* context;
1.849 +
1.850 + GET_DEVICE_NR(device, dev);
1.851 + GET_CONTEXT_NR(context, device, ctx);
1.852 +
1.853 + WFC_Context_Activate(context, WFC_FALSE);
1.854 +
1.855 + SUCCEED_NR();
1.856 +}
1.857 +
1.858 +WFC_API_CALL void WFC_APIENTRY
1.859 +wfcCompose(WFCDevice dev,
1.860 + WFCContext ctx,
1.861 + WFCboolean wait) WFC_APIEXIT
1.862 +{
1.863 + WFC_DEVICE* device;
1.864 + WFC_CONTEXT* context;
1.865 + WFCboolean able;
1.866 +
1.867 + GET_DEVICE_NR(device, dev);
1.868 + GET_CONTEXT_NR(context, device, ctx);
1.869 +
1.870 + /* context must not be active */
1.871 + COND_FAIL_NR(!WFC_Context_Active(context), WFC_ERROR_UNSUPPORTED);
1.872 +
1.873 + /* send composition request */
1.874 + able = WFC_Context_InvokeComposition(device, context, wait);
1.875 + COND_FAIL_NR(WFC_TRUE == able, WFC_ERROR_BUSY);
1.876 +
1.877 + SUCCEED_NR();
1.878 +}
1.879 +
1.880 +
1.881 +/*=========================================================================*/
1.882 +/* 9. SYNCHRONIZATION */
1.883 +/*=========================================================================*/
1.884 +
1.885 +WFC_API_CALL void WFC_APIENTRY
1.886 +wfcFence(WFCDevice dev,
1.887 + WFCContext ctx,
1.888 + WFCEGLDisplay dpy,
1.889 + WFCEGLSync sync)
1.890 +{
1.891 + WFC_DEVICE* device;
1.892 + WFC_CONTEXT* context;
1.893 +
1.894 + DPRINT(("wfcFence(%08x,%08x,%08x)", dev, ctx, sync));
1.895 +
1.896 + GET_DEVICE_NR(device, dev);
1.897 + DPRINT((" device = %p", device));
1.898 +
1.899 + GET_CONTEXT_NR(context, device, ctx);
1.900 + DPRINT((" context = %p", context));
1.901 +
1.902 + /* unsignal sync object first */
1.903 + OWF_ASSERT(context->eglPrivateSignalSync);
1.904 + if ( !(context->eglPrivateSignalSync((EGLDisplay)dpy, sync, EGL_UNSIGNALED_KHR)) )
1.905 + {
1.906 + FAIL_NR(WFC_ERROR_ILLEGAL_ARGUMENT);
1.907 + }
1.908 +
1.909 + /* insert fence 'token' to command stream */
1.910 + WFC_Context_InsertFence(context, dpy, sync);
1.911 + SUCCEED_NR();
1.912 +}
1.913 +
1.914 +/*=========================================================================*/
1.915 +/* 10. EXTENSION SUPPORT */
1.916 +/*=========================================================================*/
1.917 +
1.918 +WFC_API_CALL WFCint WFC_APIENTRY
1.919 +wfcGetStrings(WFCDevice dev,
1.920 + WFCStringID name,
1.921 + const char **strings,
1.922 + WFCint stringsCount) WFC_APIEXIT
1.923 +{
1.924 + WFC_DEVICE* pDevice;
1.925 + const char** tmp;
1.926 + WFCint retVal;
1.927 +
1.928 + GET_DEVICE(pDevice, dev, 0);
1.929 + COND_FAIL(stringsCount >= 0, WFC_ERROR_ILLEGAL_ARGUMENT, 0);
1.930 +
1.931 + switch (name)
1.932 + {
1.933 + case WFC_VENDOR:
1.934 + retVal = 1;
1.935 + tmp = &wfc_strings[WFC_VENDOR_INDEX];
1.936 + break;
1.937 +
1.938 + case WFC_RENDERER:
1.939 + retVal = 1;
1.940 + tmp = &wfc_strings[WFC_RENDERER_INDEX];
1.941 + break;
1.942 +
1.943 + case WFC_VERSION:
1.944 + retVal = 1;
1.945 + tmp = &wfc_strings[WFC_VERSION_INDEX];
1.946 + break;
1.947 +
1.948 + case WFC_EXTENSIONS:
1.949 + tmp = &wfc_extensions[0];
1.950 + /* we know that wfc_extensions always has NULL as the last member
1.951 + so this loop will never exceed the size of tmp */
1.952 + /* coverity[overrun-local] */
1.953 + for (retVal=0; tmp[retVal] != NULL; retVal++)
1.954 + {
1.955 + /* get extensions array size */
1.956 + }
1.957 + break;
1.958 +
1.959 + default:
1.960 + FAIL(WFC_ERROR_ILLEGAL_ARGUMENT, 0);
1.961 + }
1.962 +
1.963 + if (strings != NULL)
1.964 + {
1.965 + WFCint i;
1.966 +
1.967 + if (stringsCount < retVal)
1.968 + {
1.969 + retVal = stringsCount;
1.970 + }
1.971 + for (i=0; i<retVal; i++)
1.972 + {
1.973 + strings[i] = tmp[i];
1.974 + }
1.975 + }
1.976 +
1.977 + SUCCEED(retVal);
1.978 +}
1.979 +
1.980 +WFC_API_CALL WFCboolean WFC_APIENTRY
1.981 +wfcIsExtensionSupported(WFCDevice dev,
1.982 + const char *string) WFC_APIEXIT
1.983 +{
1.984 + WFC_DEVICE* pDevice;
1.985 + WFCint i;
1.986 + WFCboolean retVal = WFC_FALSE;
1.987 +
1.988 + GET_DEVICE(pDevice, dev, retVal);
1.989 + /* Bad param does not update device error state */
1.990 + COND_FAIL(string,WFC_ERROR_NONE,retVal);
1.991 +
1.992 + for (i=0; wfc_extensions[i] != NULL; i++)
1.993 + {
1.994 + if (strcmp(string, wfc_extensions[i])==0)
1.995 + {
1.996 + retVal = WFC_TRUE;
1.997 + break;
1.998 + }
1.999 + }
1.1000 +
1.1001 + SUCCEED(retVal);
1.1002 +}
1.1003 +
1.1004 +/*=========================================================================*/
1.1005 +/* 11. TEST ONLY API FOR ON SCREEN IMAGE EXPORTING */
1.1006 +/*=========================================================================*/
1.1007 +
1.1008 +WFC_API_CALL WFCNativeStreamType WFC_APIENTRY
1.1009 +extwfcGetOnScreenStream(WFCDevice dev, WFCContext ctx) WFC_APIEXIT
1.1010 +{
1.1011 + WFC_DEVICE* device;
1.1012 + WFC_CONTEXT* context;
1.1013 +
1.1014 + GET_DEVICE(device, dev, WFC_INVALID_HANDLE);
1.1015 + DPRINT((" device = %p", device));
1.1016 +
1.1017 + GET_CONTEXT(context, device, ctx, WFC_INVALID_HANDLE);
1.1018 + DPRINT((" context = %p", context));
1.1019 +
1.1020 + /* Protect context's target stream from being destroyed by the user
1.1021 + * WFC_CONTEXT_Dtor will reset this flag. */
1.1022 + owfNativeStreamSetProtectionFlag(context->stream, OWF_TRUE);
1.1023 +
1.1024 + OWF_DisplayContext_FlagInternalStreamAccessed(context->displayContext);
1.1025 +
1.1026 + SUCCEED(context->stream);
1.1027 +}