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

equal deleted inserted replaced

-:bbf46f59e123
+:25ffed67c7ef
-/* Copyright (c) 2009-2010 The Khronos Group Inc.
+/* Copyright (c) 2009 The Khronos Group Inc.
-* Portions copyright (c) 2009-2010  Nokia Corporation and/or its subsidiary(-ies)
 *
 * 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 not used for WFC element attributes because elements are
+This attribute class is currently only used for context attributes.
-completely cloned in the committed scene.
+Why isn't it used for element attributes?
-[This class could be replaced with 3 copies of a much simpler writable attributes raw
+- Because elements are completely cloned in the committed scene.
-structure with simple data members, and the whole structure copied each commit.]
+[This class could be replaced with 3 copies of a much simpler writable attributes raw
-Normal attribute values have three pointers indexed via an array:
+structure with simple data members, and the whole structure copied each commit.]
-COMMITTED_ATTR_VALUE_INDEX:
+Normal attribute values have three pointers indexed via an array:
-Attribute values used by the scene
+COMMITTED_ATTR_VALUE_INDEX:
-- points to named variables directly used by the compositor
+Attribute values used by the scene
-WORKING_ATTR_VALUE_INDEX:
+- points to named variables directly used by the compositor
-Attribute values that may be set by the client, if they are not read-only.
+WORKING_ATTR_VALUE_INDEX:
-SNAPSHOT_ATTR_VALUE_INDEX
+Attribute values that may be set by the client, if they are not read-only.
-A copy of the client-set attribute values following a client call to wfcCommit
+SNAPSHOT_ATTR_VALUE_INDEX
-The copy is then protected against further modification by the client until
+A copy of the client-set attribute values following a client call to wfcCommit
-the committed scene is updated and displayed.
+The copy is then protected against further modification by the client until
-The Working and Snapshot writable attributes require additional cache storage,
+the committed scene is updated and displayed.
-which is managed by the lifetime of the attribute list.
+The Working and Snapshot writable attributes require additional cache storage,
-Read-only attributes point all three pointers at the named compositor variables.
+which is managed by the lifetime of the attribute list.
-Currently, there are relatively few writable attributes so it is reasonable
+Read-only attributes point all three pointers at the named compositor variables.
-to individually dynamically allocate each cache. It would be better to allocate
+Currently, there are relatively few writable attributes so it is reasonable
-a single block sized after the attributes have been registered.
+to individually dynamically allocate each cache. It would be better to allocate
+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_NS(aContext);
+COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
 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_NS(aContext);
+COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
 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;
+OWFint                  index = aName - aContext->range_start;
-	COND_FAIL_NR_NS(aContext);
+COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
-	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_NS(aContext, 0);
+COND_FAIL(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT, 0);
-	COND_FAIL(aContext,
+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;
 OWFfloat                result = 0.f;
-COND_FAIL_NS(aContext, 0);
+COND_FAIL(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT, 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_NS(aContext, 0);
+COND_FAIL(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT, 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_NS(aContext, 0);
+COND_FAIL(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT, 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_NS(aContext);
+COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+CHECK_BAD_NR(aContext, aName);
 COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
-CHECK_BAD_NR(aContext, aName);
 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_NS(aContext);
+COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
+CHECK_BAD_NR(aContext, aName);
 COND_FAIL_NR(aContext, aContext->attributes, ATTR_ERROR_INVALID_CONTEXT);
-CHECK_BAD_NR(aContext, aName);
 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_NS(aContext);
+COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
 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_NS(aContext);
+COND_FAIL_NR(aContext, aContext, ATTR_ERROR_INVALID_ARGUMENT);
 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

branch	RCL_3
changeset 164	25ffed67c7ef
parent 163	bbf46f59e123