FCL/sf/os/graphics: comparison graphicscomposition/openwfcompositionengine/common/src/owfattributes.c

equal deleted inserted replaced

-:5d03bc08d59c
+:01a6848ebfd7
-/* Copyright (c) 2009 The Khronos Group Inc.
+/* Copyright (c) 2009-2010 The Khronos Group Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and/or associated documentation files (the
 * "Materials"), to deal in the Materials without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 #include <string.h>
 #include <math.h>
 #include "owfattributes.h"
 #include "owfmemory.h"
+#include "owfdebug.h"
 #define OWF_ATTRIB_RANGE_START            (0)
 #define OWF_ATTRIB_RANGE_UNINITIALIZED    (-1)
 static OWFint OWF_Attribute_Commit(OWF_ATTRIBUTE* aAttr, OWFint aDirtyFlag, OWFint aCopyTo,OWFint aCopyFrom);
 /*
-This attribute class is currently only used for context attributes.
+This attribute class is not used for WFC element attributes because elements are
-Why isn't it used for element attributes?
+completely cloned in the committed scene.
-- Because elements are completely cloned in the committed scene.
+[This class could be replaced with 3 copies of a much simpler writable attributes raw
-[This class could be replaced with 3 copies of a much simpler writable attributes raw
+structure with simple data members, and the whole structure copied each commit.]
-structure with simple data members, and the whole structure copied each commit.]
+Normal attribute values have three pointers indexed via an array:
-Normal attribute values have three pointers indexed via an array:
+COMMITTED_ATTR_VALUE_INDEX:
-COMMITTED_ATTR_VALUE_INDEX:
+Attribute values used by the scene
-Attribute values used by the scene
+- points to named variables directly used by the compositor
-- points to named variables directly used by the compositor
+WORKING_ATTR_VALUE_INDEX:
-WORKING_ATTR_VALUE_INDEX:
+Attribute values that may be set by the client, if they are not read-only.
-Attribute values that may be set by the client, if they are not read-only.
+SNAPSHOT_ATTR_VALUE_INDEX
-SNAPSHOT_ATTR_VALUE_INDEX
+A copy of the client-set attribute values following a client call to wfcCommit
-A copy of the client-set attribute values following a client call to wfcCommit
+The copy is then protected against further modification by the client until
-The copy is then protected against further modification by the client until
+the committed scene is updated and displayed.
-the committed scene is updated and displayed.
+The Working and Snapshot writable attributes require additional cache storage,
-The Working and Snapshot writable attributes require additional cache storage,
+which is managed by the lifetime of the attribute list.
-which is managed by the lifetime of the attribute list.
+Read-only attributes point all three pointers at the named compositor variables.
-Read-only attributes point all three pointers at the named compositor variables.
+Currently, there are relatively few writable attributes so it is reasonable
-Currently, there are relatively few writable attributes so it is reasonable
+to individually dynamically allocate each cache. It would be better to allocate
-to individually dynamically allocate each cache. It would be better to allocate
+a single block sized after the attributes have been registered.
-a single block sized after the attributes have been registered.
+Internal code is expected to read or write to member variables that are abstracted
+by read-only attributes. However they must not write directly to member variables
+masked by writable attributes after the initial "commit" to working. The code does
+not currently use const instances to enforce this behavior.
 */
 #define COND_FAIL_NR(ctx, condition, error) \
 if (!(condition)) { \
 if (ctx) { \
 (ctx)->last_error = error; \
 if (ctx) { \
 (ctx)->last_error = error; \
 } \
 return r; \
 }
+// NS here means No Set as we are not setting the last_error member of the context.
+// These are used when we are testing the context itself so setting the last_error
+// member is itself is an error
+#define COND_FAIL_NR_NS(condition) \
+if (!(condition)) { \
+return; \
+}
+#define COND_FAIL_NS(condition, r) \
+if (!(condition)) { \
+return r; \
+}
 #define CHECK_INDEX_NR(ctx, index, error) \
 if (index < (ctx)->range_start || index > (ctx)->range_end) { \
 (ctx)->last_error = error; \
 return; \
 OWFint aStart,
 OWFint aEnd)
 {
 OWF_ATTRIBUTE*          temp = NULL;
-COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+COND_FAIL_NR_NS(aContext);
 COND_FAIL_NR(aContext, aEnd >= 0, ATTR_ERROR_INVALID_ARGUMENT);
 COND_FAIL_NR(aContext, aEnd >= aStart, ATTR_ERROR_INVALID_ARGUMENT);
 aContext->range_start = OWF_ATTRIB_RANGE_START;
 aContext->range_end = OWF_ATTRIB_RANGE_UNINITIALIZED;
 {
 OWFint                 count = 0;
 OWFint                 at = 0;
 OWFint                 cache = 0;
-COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+COND_FAIL_NR_NS(aContext);
 COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 count = aContext->range_end - aContext->range_start;
 for (at = 0; at <= count; at++) {
 OWF_ATTRIBUTE* attr = &aContext->attributes[at];
 if (!attr->attr_info.readonly)
 {
 for (cache=0;cache<NUM_ATTR_VALUE_COPIES;cache++)
 {
 OWF_ATTRIBUTE*          attr = NULL;
 void*                   cache = NULL;
 OWFint                  itemSize;
 OWFint                  arraySize;
 OWFint                  copy;
-OWFint                  index = aName - aContext->range_start;
+OWFint                  index;
-COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+	COND_FAIL_NR_NS(aContext);
-CHECK_INDEX_NR(aContext, aName, ATTR_ERROR_INVALID_ATTRIBUTE);
+	CHECK_INDEX_NR(aContext, aName, ATTR_ERROR_INVALID_ATTRIBUTE);
 COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 COND_FAIL_NR(aContext, aLength < MAX_ATTR_LENGTH, ATTR_ERROR_CANT_HANDLE);
 COND_FAIL_NR(aContext, aType != AT_UNDEFINED, ATTR_ERROR_INVALID_ARGUMENT);
+	index = aName - aContext->range_start;
 attr = &aContext->attributes[index];
 memset(attr, 0, sizeof(OWF_ATTRIBUTE));
 /* when allocin', size DOES matter */
 if (aType == AT_INTEGER || aType == AT_BOOLEAN) {
 itemSize = sizeof(OWFint);
 } else {
 itemSize = sizeof(OWFfloat);
 }
 arraySize=itemSize*aLength;
 /* don't allocate cache for read-only 'butes */
 attr->attr_info.type        = aType;
 attr->attr_info.length      = aLength;
 attr->attr_info.readonly    = aRdOnly;
 attr->attr_info.size        = itemSize;
 cache = xalloc(arraySize,1);
 COND_FAIL_NR(aContext, NULL != cache, ATTR_ERROR_NO_MEMORY);
 attr->attr_value[copy].gen_ptr = cache;
 }
 }
-OWF_Attribute_Commit(attr,1,
-WORKING_ATTR_VALUE_INDEX,COMMITTED_ATTR_VALUE_INDEX);
 }
 SET_ERROR(aContext, ATTR_ERROR_NONE);
 }
 {
 OWFint                  index = 0;
 OWF_ATTRIBUTE*          attr = 0;
 OWFint                  result = 0;
-COND_FAIL(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT, 0);
+COND_FAIL_NS(aContext, 0);
+	COND_FAIL(aContext,
+aContext->attributes,
+ATTR_ERROR_INVALID_CONTEXT,
+0);
 CHECK_BAD(aContext, aName, 0);
+index = aName - aContext->range_start;
+attr = &aContext->attributes[index];
+COND_FAIL(aContext,
+1 == attr->attr_info.length,
+ATTR_ERROR_INVALID_TYPE,
+0);
+SET_ERROR(aContext, ATTR_ERROR_NONE);
+switch (attr->attr_info.type) {
+case AT_FLOAT: {
+result = floor(attr->attr_value[WORKING_ATTR_VALUE_INDEX].float_value[0]);
+break;
+}
+case AT_INTEGER:
+case AT_BOOLEAN: {
+result = attr->attr_value[WORKING_ATTR_VALUE_INDEX].int_value[0];
+break;
+}
+default: {
+SET_ERROR(aContext, ATTR_ERROR_INVALID_TYPE);
+break;
+}
+}
+return result;
+}
+/*
+* \brief Return boolean attribute value
+*
+* \param aContext Attribute context
+* \param aName Attribute name
+*
+* \return Attribute value
+* ATTR_ERROR_INVALID_ATTRIBUTE
+* ATTR_ERROR_INVALID_TYPE
+*/
+OWF_API_CALL OWFboolean
+OWF_Attribute_GetValueb(OWF_ATTRIBUTE_LIST* aContext,
+OWFint aName)
+{
+/* boolean is stored as int, must cast */
+return (OWFboolean) OWF_Attribute_GetValuei(aContext, aName);
+}
+/*
+* \brief Get attribute float value
+*
+* \param aContext
+* \param aName
+* \param aValue
+*
+* \return Attribute
+*/
+OWF_API_CALL OWFfloat
+OWF_Attribute_GetValuef(OWF_ATTRIBUTE_LIST* aContext,
+OWFint aName)
+{
+OWFint                 index = 0;
+OWF_ATTRIBUTE*          attr = NULL;
+OWFfloat                result = 0.f;
+COND_FAIL_NS(aContext, 0);
 COND_FAIL(aContext,
 aContext->attributes,
 ATTR_ERROR_INVALID_CONTEXT,
 0);
-index = aName - aContext->range_start;
-attr = &aContext->attributes[index];
-COND_FAIL(aContext,
-1 == attr->attr_info.length,
-ATTR_ERROR_INVALID_TYPE,
-0);
-SET_ERROR(aContext, ATTR_ERROR_NONE);
-switch (attr->attr_info.type) {
-case AT_FLOAT: {
-result = floor(attr->attr_value[WORKING_ATTR_VALUE_INDEX].float_value[0]);
-break;
-}
-case AT_INTEGER:
-case AT_BOOLEAN: {
-result = attr->attr_value[WORKING_ATTR_VALUE_INDEX].int_value[0];
-break;
-}
-default: {
-SET_ERROR(aContext, ATTR_ERROR_INVALID_TYPE);
-break;
-}
-}
-return result;
-}
-/*
-* \brief Return boolean attribute value
-*
-* \param aContext Attribute context
-* \param aName Attribute name
-*
-* \return Attribute value
-* ATTR_ERROR_INVALID_ATTRIBUTE
-* ATTR_ERROR_INVALID_TYPE
-*/
-OWF_API_CALL OWFboolean
-OWF_Attribute_GetValueb(OWF_ATTRIBUTE_LIST* aContext,
-OWFint aName)
-{
-/* boolean is stored as int, must cast */
-return (OWFboolean) OWF_Attribute_GetValuei(aContext, aName);
-}
-/*
-* \brief Get attribute float value
-*
-* \param aContext
-* \param aName
-* \param aValue
-*
-* \return Attribute
-*/
-OWF_API_CALL OWFfloat
-OWF_Attribute_GetValuef(OWF_ATTRIBUTE_LIST* aContext,
-OWFint aName)
-{
-OWFint                 index = 0;
-OWF_ATTRIBUTE*          attr = NULL;
-OWFfloat                result = 0.f;
-COND_FAIL(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT, 0);
 CHECK_BAD(aContext, aName, 0);
-COND_FAIL(aContext,
-aContext->attributes,
-ATTR_ERROR_INVALID_CONTEXT,
-0);
 index = aName - aContext->range_start;
 attr = &aContext->attributes[index];
 COND_FAIL(aContext,
 {
 OWFint                 index = 0;
 OWF_ATTRIBUTE*          attr = NULL;
 OWFint                 count = 0;
-COND_FAIL(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT, 0);
+COND_FAIL_NS(aContext, 0);
-CHECK_BAD(aContext, aName, 0);
 COND_FAIL(aContext,
 aContext->attributes,
 ATTR_ERROR_INVALID_CONTEXT,
 0);
+CHECK_BAD(aContext, aName, 0);
 index = aName - aContext->range_start;
 attr = &aContext->attributes[index];
 COND_FAIL(aContext,
 {
 OWFint                 index = 0;
 OWF_ATTRIBUTE*          attr = NULL;
 OWFint                 count = 0;
-COND_FAIL(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT, 0);
+COND_FAIL_NS(aContext, 0);
-CHECK_BAD(aContext, aName, 0);
 COND_FAIL(aContext,
 aContext->attributes,
 ATTR_ERROR_INVALID_CONTEXT,
 0);
+CHECK_BAD(aContext, aName, 0);
 index = aName - aContext->range_start;
 attr = &aContext->attributes[index];
 COND_FAIL(aContext,
 OWFint aValue)
 {
 OWFint                 index = 0;
 OWF_ATTRIBUTE*          attr = NULL;
-COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+COND_FAIL_NR_NS(aContext);
+COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 CHECK_BAD_NR(aContext, aName);
-COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 index = aName - aContext->range_start;
 attr = &aContext->attributes[index];
 COND_FAIL_NR(aContext,
 OWFfloat aValue)
 {
 OWFint                 index = 0;
 OWF_ATTRIBUTE*          attr = NULL;
-COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+COND_FAIL_NR_NS(aContext);
+COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 CHECK_BAD_NR(aContext, aName);
-COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 index = aName - aContext->range_start;
 attr = &aContext->attributes[index];
 COND_FAIL_NR(aContext,
 {
 OWFint                 index = 0;
 OWF_ATTRIBUTE*          attr = NULL;
 OWFint                 count = 0;
-COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+COND_FAIL_NR_NS(aContext);
 COND_FAIL_NR(aContext, aValue, ATTR_ERROR_INVALID_ARGUMENT);
 COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 CHECK_BAD_NR(aContext, aName);
 index = aName - aContext->range_start;
 {
 OWFint                 index = 0;
 OWF_ATTRIBUTE*          attr = NULL;
 OWFint                 count = 0;
-COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+COND_FAIL_NR_NS(aContext);
 COND_FAIL_NR(aContext, aValue, ATTR_ERROR_INVALID_ARGUMENT);
 COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 CHECK_BAD_NR(aContext, aName);
 index = aName - aContext->range_start;
 static OWFint OWF_Attribute_Commit(OWF_ATTRIBUTE* aAttr,
 OWFint aDirtyFlag,
 OWFint aCopyTo,
 OWFint aCopyFrom )
 {
+	OWF_ASSERT(aCopyTo >= 0);
+	OWF_ASSERT(aCopyTo < NUM_ATTR_VALUE_COPIES);
+	OWF_ASSERT(aCopyFrom >= 0);
+	OWF_ASSERT(aCopyFrom < NUM_ATTR_VALUE_COPIES);
 /* if type is undefined, it means there're gaps in the attribute
 range (e.g. reservations for future use and such.) ignore them. */
 if (aAttr->attr_info.type != AT_UNDEFINED && aDirtyFlag)
 {
 /* poor-man's commit */
 {
 return aDirtyFlag;
 }
 }
 OWF_API_CALL void
 OWF_AttributeList_Commit(OWF_ATTRIBUTE_LIST* aContext,
 OWFint aStart,
 OWFint aEnd,
-OWFint aCopyTo )
+		     OWFint aCopyTo )
 {
 OWFint                 index = 0;
 /* Attribute commit works like the element list commit
 * by forward-copying the "working" attributes to the snapshot
 * during client invoked commit,
 * then copying the snapshot to the commited scene during the docommit job.
 * This requires the same wait-for-the-previous-commit-job strategy used in the element commit.
 * Could in future use copy-back technique to avoid having to wait substantially,
 * in which case the index of the working attribute set would switch after each invoked commit,
 * instead of being a constant.
+*
 * The same number of copies would still need to take place
 * but would not need exclusive access to the list.
 */
-COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+COND_FAIL_NR_NS(aContext);
 COND_FAIL_NR(aContext, aStart <= aEnd, ATTR_ERROR_INVALID_ARGUMENT);
 COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
 CHECK_BAD_NR(aContext, aStart);
 CHECK_BAD_NR(aContext, aEnd);
 switch (aCopyTo)
 {
-case COMMITTED_ATTR_VALUE_INDEX: //Used in composition thread to set displayed scene attributes
+case COMMITTED_ATTR_VALUE_INDEX: /* Used in composition thread to set displayed scene attributes */
 for (index = aStart; index <= aEnd; index++)
 {
 OWF_ATTRIBUTE* attr = &aContext->attributes[index - aContext->range_start];
 attr->attr_info.dirtysnapshot=
 OWF_Attribute_Commit(attr,attr->attr_info.dirtysnapshot,
 COMMITTED_ATTR_VALUE_INDEX,SNAPSHOT_ATTR_VALUE_INDEX);
 }
 break;
-case SNAPSHOT_ATTR_VALUE_INDEX: //Used in API threads to make a snapshot of the client attributes
+case SNAPSHOT_ATTR_VALUE_INDEX: /* Used in API threads to make a snapshot of the client attributes */
 for (index = aStart; index <= aEnd; index++)
 {
 OWF_ATTRIBUTE* attr = &aContext->attributes[index - aContext->range_start];
 OWFuint oldDirty=attr->attr_info.dirty;
 attr->attr_info.dirtysnapshot=oldDirty;
 attr->attr_info.dirty=
 OWF_Attribute_Commit(attr,oldDirty,
 SNAPSHOT_ATTR_VALUE_INDEX,WORKING_ATTR_VALUE_INDEX);
 }
 break;
-case WORKING_ATTR_VALUE_INDEX:   //Used in initialisation to copy displayed attributes to client copies
+case WORKING_ATTR_VALUE_INDEX:   /* Used in initialisation to copy displayed attributes to client copies */
 for (index = aStart; index <= aEnd; index++)
 {
 OWF_ATTRIBUTE* attr = &aContext->attributes[index - aContext->range_start];
 OWF_Attribute_Commit(attr,!attr->attr_info.readonly,
 WORKING_ATTR_VALUE_INDEX,COMMITTED_ATTR_VALUE_INDEX);
 }
 break;
+	case COMMIT_ATTR_DIRECT_FROM_WORKING: /* Used in WFD to commit new working values directly in 1 step. */
-}
+for (index = aStart; index <= aEnd; index++)
+{
+OWF_ATTRIBUTE* attr = &aContext->attributes[index - aContext->range_start];
+attr->attr_info.dirty=
+OWF_Attribute_Commit(attr,attr->attr_info.dirty,
+COMMITTED_ATTR_VALUE_INDEX,WORKING_ATTR_VALUE_INDEX);
+}
+break;
+	default:
+			COND_FAIL_NR(aContext, 0, ATTR_ERROR_INVALID_ARGUMENT);
+}
 SET_ERROR(aContext, ATTR_ERROR_NONE);
 }
 #ifdef __cplusplus

changeset 36	01a6848ebfd7
parent 0	5d03bc08d59c
child 152	9f1c3fea0f87