Esempio n. 1
0
boolean nx_config_cache_get_string(const char *module, const char *key, const char **result)
{
    nx_ctx_t *ctx;
    nx_cc_item_t *item;
    char ckey[NX_CONFIG_CACHE_MAX_KEYLEN];

    ASSERT(module != NULL);
    ASSERT(key != NULL);

    ctx = nx_ctx_get();

    if ( apr_snprintf(ckey, sizeof(ckey), "%s/%s", module, key) == sizeof(ckey) )
    {
	nx_panic("config cache key too long, limit is %d bytes", NX_CONFIG_CACHE_MAX_KEYLEN);
    }

    CHECKERR(apr_thread_mutex_lock(ctx->config_cache_mutex));
    item = (nx_cc_item_t *) apr_hash_get(ctx->config_cache, ckey, APR_HASH_KEY_STRING);
    CHECKERR(apr_thread_mutex_unlock(ctx->config_cache_mutex));

    if ( item == NULL )
    {
	return ( FALSE );
    }

    if ( (strcmp(item->key, ckey) == 0) && (item->value->type == NX_VALUE_TYPE_STRING) )
    {
	ASSERT(item->value->string != NULL);
	*result = item->value->string->buf;
	item->used = TRUE;
	return ( TRUE );
    }

    return ( FALSE );
}
Esempio n. 2
0
void nx_config_cache_free()
{
    nx_ctx_t *ctx;
    nx_cc_item_t *item = NULL;
    apr_hash_index_t *idx;
    const char *key;
    apr_ssize_t keylen;

    ctx = nx_ctx_get();

    CHECKERR(apr_thread_mutex_lock(ctx->config_cache_mutex));
    for ( idx = apr_hash_first(NULL, ctx->config_cache);
	  idx != NULL;
	  idx = apr_hash_next(idx) )
    {
	apr_hash_this(idx, (const void **) &key, &keylen, (void **) &item);
	apr_hash_set(ctx->config_cache, item->key, APR_HASH_KEY_STRING, NULL);
	_free_item(item);
    }
    if ( ctx->ccfile != NULL )
    {
	apr_file_close(ctx->ccfile);
	ctx->ccfile = NULL;
    }
    CHECKERR(apr_thread_mutex_unlock(ctx->config_cache_mutex));
}
Esempio n. 3
0
void MarcPostDB::node_vector(int indexN,int indexV,PyVector *pVec)
{
	GETFUNC(m_pFile,"node_vector",Func_NodeVector,"**ERROR** Function node_vector() not found");
	PyObject *pParam = Py_BuildValue("(i,i)",indexN,indexV);
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_NodeVector],pParam);
	CHECKERR();
	PyObject *val = PyObject_GetAttrString(ret,"id");
	pVec->id = PyInt_AsLong(val);
	Py_DECREF(val);

	val = PyObject_GetAttrString(ret,"x");
	*(pVec->val)= PyFloat_AsDouble(val);
	Py_DECREF(val);

	val = PyObject_GetAttrString(ret,"y");
	*(pVec->val+1)= PyFloat_AsDouble(val);
	Py_DECREF(val);

	val = PyObject_GetAttrString(ret,"z");
	*(pVec->val+2)= PyFloat_AsDouble(val);
	Py_DECREF(val);

	Py_DECREF(ret);
	Py_DECREF(pParam);
}
Esempio n. 4
0
int MarcPostDB::element_scalar(int indexE,int indexS,PyScalar **ppScalar)
{
	GETFUNC(m_pFile,"element_scalar",Func_ElementScalar,"**ERROR** Function element_scalar() not found");
	PyObject *pParam = Py_BuildValue("(i,i)",indexE,indexS);
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_ElementScalar],pParam);
	CHECKERR();

	int len = 0;
	if (PyList_Check(ret))
	{
		len = PyList_Size(ret);
		PyObject *item = 0;
		for (int i = 0; i < len; i++)
		{
			item = PyList_GetItem(ret,i);

			PyObject *val = PyObject_GetAttrString(item,"id");
			m_oScalar[i].nId = PyInt_AsLong(val);
			Py_DECREF(val);

			val = PyObject_GetAttrString(item,"value");
			m_oScalar[i].val = PyFloat_AsDouble(val);
			Py_DECREF(val);

			//Py_DECREF(item);
		}
	}
	Py_DECREF(ret);
	Py_DECREF(pParam);
	*ppScalar = m_oScalar;
	return len;
}
Esempio n. 5
0
int main()
{
	int i;
	int err = 0;
	emsuinput_context* ctx = NULL;

	int keybits[] = {
		BTN_LEFT,
	};

	int relbits[] = {
		REL_X,
		REL_Y,
	};

	ctx = emsuinput_new_context("fakemouse", keybits, 1, relbits, 2);
	if (ctx == NULL) {
		exit(-1);
	}

	for (i = 0; i < 100; i++) {
		err = emsuinput_send_rel_xy(ctx, 10, 10);
		CHECKERR(err);
		usleep(10 * 1000);
	}

	/* err = emsuinput_send_rel_xy(ctx, -3000, -3000); */
	/* err = emsuinput_send_rel_xy(ctx, 640, 480); */

	emsuinput_release_context(ctx);

	exit(0);

}
Esempio n. 6
0
void MarcPostDB::node(int index,PyNode *pNode)
{
	GETFUNC(m_pFile,"node",Func_Node,"**ERROR** Function node() not found");
	PyObject *pParam = Py_BuildValue("(i)",index);
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_Node],pParam);
	CHECKERR();
	PyObject *val = PyObject_GetAttrString(ret,"id");
	pNode->id = PyInt_AsLong(val);
	Py_DECREF(val);

	val = PyObject_GetAttrString(ret,"x");
	*(pNode->coord)= PyFloat_AsDouble(val);
	Py_DECREF(val);

	val = PyObject_GetAttrString(ret,"y");
	*(pNode->coord+1)= PyFloat_AsDouble(val);
	Py_DECREF(val);

	val = PyObject_GetAttrString(ret,"z");
	*(pNode->coord+2)= PyFloat_AsDouble(val);
	Py_DECREF(val);

	Py_DECREF(pParam);
	Py_DECREF(ret);
}
Esempio n. 7
0
CML_Error CML_NodeFindContainer(CML_Node * node, char * path, CML_Node ** result)
{
    CHECKPTR(node  );
    CHECKPTR(result);

    char next[256];
    char curr[256];
    path_curr(path, curr);
    path_next(path, next);
    uint32_t index;

    CHECKERR(CML_NodeFindIndex(node, curr, &index));

    if (next[0]) /* go deeper */
        CHECKERR(CML_NodeFindContainer(node->nodes[index], next, result))
    else /* stay here */
    {
        if ((node->nodes[index]->type == CML_TYPE_ARRAY) ||
            (node->nodes[index]->type == CML_TYPE_HASH))
            *result = node->nodes[index];
        else
            return CML_ERROR_USER_BADTYPE;
    }


    return CML_ERROR_SUCCESS;
}
Esempio n. 8
0
CML_Error CML_NodeFind(CML_Node * node, char * path, CML_Node ** result, CML_Type type)
{
    CHECKPTR(node  );
    CHECKTYP(type  );
    CHECKPTR(result);

    char next[1024];
    char curr[1024];
    path_curr(path, curr);
    path_next(path, next);
    uint32_t index;

    CHECKERR(CML_NodeFindIndex(node, curr, &index));

    if (next[0]) /* go deeper */
        CHECKERR(CML_NodeFind(node->nodes[index], next, result, type))
    else /* stay here */
    {
        if (node->nodes[index]->type == type)
            *result = node->nodes[index];
        else
            return CML_ERROR_USER_BADTYPE;
    }


    return CML_ERROR_SUCCESS;
}
Esempio n. 9
0
void MarcPostDB::moveto(int i)
{
	GETFUNC(m_pFile,"moveto",Func_MoveTo,"**ERROR** Function moveto() not found");
	PyObject *pParam = Py_BuildValue("(i)",i);
	PyEval_CallObject((PyObject *)m_pFunc[Func_MoveTo],pParam);
	CHECKERR();
	Py_DECREF(pParam);
}
Esempio n. 10
0
int MarcPostDB::node_vectors()
{
	GETFUNC(m_pFile,"node_vectors",Func_NodeVectors,"**ERROR** Function node_vectors() not found");
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_NodeVectors],NULL);
	CHECKERR();
	int i = PyInt_AsLong(ret);
	Py_DECREF(ret);
	return i;
}
Esempio n. 11
0
int MarcPostDB::increments()
{
	GETFUNC(m_pFile,"increments",Func_Increments,"**ERROR** Function increments() not found");
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_Increments],NULL);
	CHECKERR();
	int i = PyInt_AsLong(ret);
	Py_DECREF(ret);
	return i;
}
Esempio n. 12
0
char* MarcPostDB::version()
{
	GETFUNC(m_pMod,"version",Func_Version,"**ERROR** Function version() not found");
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_Version],NULL);
	CHECKERR();
	strcpy_s(m_cStr,128,PyString_AsString(ret));
	Py_DECREF(ret);
	return m_cStr;
}
Esempio n. 13
0
char* MarcPostDB::title()
{
	GETFUNC(m_pFile,"title",Func_Title,"**ERROR** Function title() not found");
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_Title],NULL);
	CHECKERR();
	strcpy_s(m_cStr,128,PyString_AsString(ret));
	Py_DECREF(ret);
	return m_cStr;
}
Esempio n. 14
0
int CreateInitSockClient(HWND hwnd, SOCKET& sock, sockaddr_in sa, char *buf)
{
	int i;
	char lineErr[256], buf2[128];
	CHECKERR(sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP), FL_ERR_SOCKET);
	CHECKERR(i = WSAAsyncSelect (sock, hwnd, WM_FLY_TASKS, FD_CONNECT | FD_WRITE | FD_READ | FD_CLOSE ), FL_ERR_WSAAYNC);
	i=connect (sock, (SOCKADDR *)&sa, sizeof(sa));
	if (i==-1)
	{
		if (WSAGetLastError()!=WSAEWOULDBLOCK)
		{
			sprintf(buf, "code=%d", i);
			MessageBox (NULL, buf, "Error in connect", MB_OK);
		}
	}
	_beginthreadex (NULL, 0, ConnectingThread, (void*)sock, 0, &connectThreadID);
	return i;
}
Esempio n. 15
0
int MarcPostDB::element_tensors()
{
	GETFUNC(m_pFile,"element_tensors",Func_ElementTensors,"**ERROR** Function element_tensors() not found");
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_ElementTensors],NULL);
	CHECKERR();
	int i = PyInt_AsLong(ret);
	Py_DECREF(ret);
	return i;
}
Esempio n. 16
0
void initCL()
{
    FILE *kernelFile;
    char *kernelSource;
    size_t kernelLength;

    cl_int errcode;
	
    ocd_options opts = ocd_get_options();
	platform_id = opts.platform_id;
	device_id = opts.device_id;

clDevice = GetDevice(platform_id, device_id);
	size_t max_worksize[3];
errcode = clGetDeviceInfo(clDevice, CL_DEVICE_MAX_WORK_ITEM_SIZES,sizeof(size_t)*3, &max_worksize, NULL);
 CHECKERR(errcode);
        while(num_threads_perdim*num_threads_perdim>max_worksize[0])
                num_threads_perdim = num_threads_perdim/2;

	num_threads = num_threads_perdim*num_threads_perdim;
	
    clContext = clCreateContext(NULL, 1, &clDevice, NULL, NULL, &errcode);
    CHECKERR(errcode);

    clCommands = clCreateCommandQueue(clContext, clDevice, CL_QUEUE_PROFILING_ENABLE, &errcode);
    CHECKERR(errcode);

    kernelFile = fopen("kmeans_opencl_kernel.cl", "r");
    fseek(kernelFile, 0, SEEK_END);
    kernelLength = (size_t) ftell(kernelFile);
    kernelSource = (char *) malloc(sizeof(char)*kernelLength);
    rewind(kernelFile);
    fread((void *) kernelSource, kernelLength, 1, kernelFile);
    fclose(kernelFile);

    clProgram = clCreateProgramWithSource(clContext, 1, (const char **) &kernelSource, &kernelLength, &errcode);
    CHECKERR(errcode);

    free(kernelSource);

    errcode = clBuildProgram(clProgram, 1, &clDevice, NULL, NULL, NULL);
    if (errcode == CL_BUILD_PROGRAM_FAILURE)
    {
        char *log;
        size_t logLength;
        errcode = clGetProgramBuildInfo(clProgram, clDevice, CL_PROGRAM_BUILD_LOG, 0, NULL, &logLength);
        log = (char *) malloc(sizeof(char)*logLength);
        errcode = clGetProgramBuildInfo(clProgram, clDevice, CL_PROGRAM_BUILD_LOG, logLength, (void *) log, NULL);
        fprintf(stderr, "Kernel build error! Log:\n%s", log);
        free(log);
        return;
    }
    CHECKERR(errcode);

    clKernel_invert_mapping = clCreateKernel(clProgram, "invert_mapping", &errcode);
    CHECKERR(errcode);
    clKernel_kmeansPoint = clCreateKernel(clProgram, "kmeansPoint", &errcode);
    CHECKERR(errcode);
}
Esempio n. 17
0
static void _update_item(nx_cc_item_t *item)
{
    nx_ctx_t *ctx;
    apr_off_t offs;
    nx_exception_t e;

    ASSERT(item->value != NULL);

    ctx = nx_ctx_get();

    CHECKERR(apr_thread_mutex_lock(ctx->config_cache_mutex));
    try
    {
	if ( ctx->ccfile == NULL )
	{
	    CHECKERR_MSG(apr_file_open(&(ctx->ccfile), ctx->ccfilename,
				       APR_READ | APR_WRITE | APR_CREATE | APR_TRUNCATE,
				       APR_OS_DEFAULT, ctx->pool),
			 "couldn't open config cache '%s' for writing", ctx->ccfilename);
	}
	// only integers are supported for now, string modifications trigger a whole rewrite
	if ( (item->offs > 0) && (item->value->type == NX_VALUE_TYPE_INTEGER) )

	{
	    offs = item->offs;
	    CHECKERR_MSG(apr_file_seek(ctx->ccfile, APR_SET, &offs),
			 "failed to seek in %s file", ctx->ccfilename);
	    CHECKERR_MSG(nx_value_to_file(item->value, ctx->ccfile), "failed to update config cache item");
	}
	else
	{ // write the whole file, not very efficient
	    nx_config_cache_write();
	}
	item->needflush = FALSE;
    }
    catch(e)
    {
	CHECKERR(apr_thread_mutex_unlock(ctx->config_cache_mutex));
	rethrow(e);
    }
    CHECKERR(apr_thread_mutex_unlock(ctx->config_cache_mutex));
}
Esempio n. 18
0
void nx_config_cache_set_string(const char *module, const char *key, const char *value)
{
    nx_ctx_t *ctx;
    nx_cc_item_t *item;
    char ckey[NX_CONFIG_CACHE_MAX_KEYLEN];

    ASSERT(module != NULL);
    ASSERT(key != NULL);
    ASSERT(value != NULL);

    ctx = nx_ctx_get();

    if ( apr_snprintf(ckey, sizeof(ckey), "%s/%s", module, key) == sizeof(ckey) )
    {
	nx_panic("config cache key too long, limit is %d bytes", NX_CONFIG_CACHE_MAX_KEYLEN);
    }

    CHECKERR(apr_thread_mutex_lock(ctx->config_cache_mutex));
    item = (nx_cc_item_t *) apr_hash_get(ctx->config_cache, ckey, APR_HASH_KEY_STRING);
    CHECKERR(apr_thread_mutex_unlock(ctx->config_cache_mutex));

    if ( item != NULL )
    {
	ASSERT(item->value->type == NX_VALUE_TYPE_STRING);
	nx_value_free(item->value);
	item->value = nx_value_new_string(value);
	item->used = TRUE;
	item->needflush = TRUE;
    }
    else
    {
	item = malloc(sizeof(nx_cc_item_t));
	memset(item, 0, sizeof(nx_cc_item_t));
	item->key = strdup(ckey);
	item->value = nx_value_new_string(value);
	item->used = TRUE;
	item->needflush = TRUE;
	CHECKERR(apr_thread_mutex_lock(ctx->config_cache_mutex));
	apr_hash_set(ctx->config_cache, item->key, APR_HASH_KEY_STRING, (void *) item);
	CHECKERR(apr_thread_mutex_unlock(ctx->config_cache_mutex));
    }
}
Esempio n. 19
0
int MarcPostDB::element_id(int index)
{
	GETFUNC(m_pFile,"element_id",Func_ElementId,"**ERROR** Function element_id() not found");
	PyObject *pParam = Py_BuildValue("(i)",index);
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_ElementId],pParam);
	CHECKERR();
	int i = PyInt_AsLong(ret);
	Py_DECREF(ret);
	Py_DECREF(pParam);
	return i;
}
Esempio n. 20
0
double MarcPostDB::node_scalar(int indexN,int indexS)
{
	GETFUNC(m_pFile,"node_scalar",Func_NodeScalar,"**ERROR** Function node_scalar() not found");
	PyObject *pParam = Py_BuildValue("(i,i)",indexN,indexS);
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_NodeScalar],pParam);
	CHECKERR();
	double d = PyFloat_AsDouble(ret);
	Py_DECREF(ret);
	Py_DECREF(pParam);
	return d;
}
Esempio n. 21
0
char* MarcPostDB::element_tensor_label(int index)
{
	GETFUNC(m_pFile,"element_tensor_label",Func_ElementTensorLabel,"**ERROR** Function element_tensor_label() not found");
	PyObject *pParam = Py_BuildValue("(i)",index);
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_ElementTensorLabel],pParam);
	CHECKERR();
	strcpy_s(m_cStr,128,PyString_AsString(ret));
	Py_DECREF(ret);
	Py_DECREF(pParam);
	return m_cStr;
}
Esempio n. 22
0
void MarcPostDB::element(int index,PyElement *pElement)
{
	GETFUNC(m_pFile,"element",Func_Element,"**ERROR** Function element() not found");
	PyObject *pParam = Py_BuildValue("(i)",index);
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_Element],pParam);
	CHECKERR();

	PyObject *val = PyObject_GetAttrString(ret,"id");
	pElement->id = PyInt_AsLong(val);
	Py_DECREF(val);
	CHECKERR();

	val = PyObject_GetAttrString(ret,"type");
	pElement->elemType = PyInt_AsLong(val);
	Py_DECREF(val);

	val = PyObject_GetAttrString(ret,"len");
	pElement->nodeCnt = PyInt_AsLong(val);
	Py_DECREF(val);

	val = PyObject_GetAttrString(ret,"items");
	if (PyList_Check(val))
	{
		int len = PyList_Size(val);
		PyObject *item = 0;
		for (int i = 0; i < len; i++)
		{
			item = PyList_GetItem(val,i);
			pElement->nodeId[i] = PyInt_AsLong(item);
			//Py_DECREF(item);
		}
	}
	Py_DECREF(val);
	CHECKERR();

	Py_DECREF(ret);
	Py_DECREF(pParam);
}
Esempio n. 23
0
bool MarcPostDB::open(char *fname)
{
	GETFUNC(m_pMod,"post_open",Func_PostOpen,"**ERROR** Function post_open() not found");
	PyObject *pParam = Py_BuildValue("(s)",fname);
	m_pFile = (void *)PyEval_CallObject((PyObject *)m_pFunc[Func_PostOpen],pParam);
	CHECKERR();
	Py_DECREF(pParam);
	if (m_pFile == 0)
	{
		printf("%s\n","**ERROR** DB open failed");
		return false;
	}
	return true;
}
Esempio n. 24
0
apr_pool_t *nx_pool_create_core()
{
    apr_pool_t *pool;
    apr_allocator_t *allocator;
    apr_thread_mutex_t *mutex;

    CHECKERR(apr_allocator_create(&allocator));
    
#ifdef HAVE_APR_POOL_CREATE_UNMANAGED_EX
    // older apr does not have this
    CHECKERR(apr_pool_create_unmanaged_ex(&pool, &abort_func, allocator)); 
#else
    CHECKERR(apr_pool_create_ex(&pool, NULL, &abort_func, allocator)); 
#endif
    allocator = apr_pool_allocator_get(pool);
    apr_allocator_owner_set(allocator, pool);
    ASSERT(allocator != NULL);
    apr_allocator_max_free_set(allocator, NX_MAX_ALLOCATOR_SIZE);
    CHECKERR(apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_UNNESTED, pool));
    apr_allocator_mutex_set(allocator, mutex);

    return ( pool );
}
Esempio n. 25
0
char* get_pvars_name_list()
{
	int num, i;
	char *name;
	char *class_name;
	int bind,vc,verbos,ro,ct,at;
	MPI_Datatype dt;
	MPI_T_enum et;
	int namelen, desclen;
	int total_length_of_pvar_names;
	char fname[105];
	char fdesc[105];
	int index;
	/* Get number of variables */

	MPI_T_pvar_get_num(&num);

	/* Find string sizes */
	total_length_of_pvar_names = 0;
	for (i = 0; i<num; i++)
	{
		int namelen = 0;
		int desclen = 0;
		MPI_T_pvar_get_info(i,fname,&namelen,&verbos,&vc,&dt,&et,fdesc,&desclen,&bind,&ro,&ct,&at);
		total_length_of_pvar_names += namelen;
	}

	/* Allocate string buffers */
	name = (char*)malloc(sizeof(char)* (total_length_of_pvar_names + num * 8 /*strlen(:CLASS_NAME)*/ + num /*delimiter*/ + 1));
	CHECKERR("Malloc Name",(name==NULL));
	index = 0;
	for (i = 0; i < num; i++)
	{
		namelen = 0;
		desclen = 0;
		MPI_T_pvar_get_info(i,fname,&namelen,&verbos,&vc,&dt,&et,fdesc,&desclen,&bind,&ro,&ct,&at);
		memcpy((name + index), fname, namelen);
		index += namelen;
		memcpy((name + index), ":", 1);
		index += 1;
		class_name = get_pvar_class(vc);
		memcpy((name+index), class_name, strlen(class_name));
		index += strlen(class_name);
		memcpy((name + index), ";", 1);
		index += 1;
	}
	name[index] = 0;
	return name;
}
Esempio n. 26
0
apr_pool_t *nx_pool_create_child(apr_pool_t *parent)
{
    apr_pool_t *pool;
    apr_allocator_t *allocator;

    CHECKERR(apr_pool_create_ex(&pool, parent, &abort_func, NULL));
    if ( parent == NULL )
    {
	allocator = apr_pool_allocator_get(pool);
	ASSERT(allocator != NULL);
	apr_allocator_max_free_set(allocator, NX_MAX_ALLOCATOR_SIZE);
    }

    return ( pool );
}
Esempio n. 27
0
MarcPostDB::MarcPostDB():m_pFile(0),m_pMod(0)
{
	for(int i = 0; i < FuncCount; i++)
	{
		m_pFunc[i] = 0;
	}
	//Py_SetPythonHome();
	Py_Initialize();
	if (!Py_IsInitialized())
	{
		printf("%s/n","**ERROR** Python initialize failed");
	}
	m_pMod = (void *)PyImport_ImportModule("py_post");
	CHECKERR();
	if (m_pMod == 0)
	{
		printf("%s\n","**ERROR** Module import failed");
	}
}
Esempio n. 28
0
int MarcPostDB::element_vector(int indexE,int indexV,PyVector **ppVector)
{
	GETFUNC(m_pFile,"element_vector",Func_ElementVector,"**ERROR** Function element_vector() not found");
	PyObject *pParam = Py_BuildValue("(i,i)",indexE,indexV);
	PyObject * ret = PyEval_CallObject((PyObject *)m_pFunc[Func_ElementVector],pParam);
	CHECKERR();

	int len = 0;
	if (PyList_Check(ret))
	{
		len = PyList_Size(ret);
		PyObject *item = 0;
		for (int i = 0; i < len; i++)
		{
			item = PyList_GetItem(ret,i);

			PyObject *val = PyObject_GetAttrString(item,"id");
			m_oVector[i].id = PyInt_AsLong(val);
			Py_DECREF(val);

			val = PyObject_GetAttrString(item,"x");
			m_oVector[i].val[0] = PyFloat_AsDouble(val);
			Py_DECREF(val);

			val = PyObject_GetAttrString(item,"y");
			m_oVector[i].val[1] = PyFloat_AsDouble(val);
			Py_DECREF(val);

			val = PyObject_GetAttrString(item,"z");
			m_oVector[i].val[2] = PyFloat_AsDouble(val);
			Py_DECREF(val);

			//Py_DECREF(item);
		}
	}
	Py_DECREF(ret);
	Py_DECREF(pParam);
	*ppVector = m_oVector;
	return len;
}
Esempio n. 29
0
// MT : this is a compatibility routine to do stuff that used to be done in the cfm initialiser of rezlib
static Handle LoadDITL()
{
	//Load the dialog item list for our AskIfNewResolutionWorks() function dialog box
	static Handle		s_ditl=NULL;
	if (!s_ditl)
	{
		//Load our DITL
		s_ditl = Get1Resource( 'DITL', 27398 );
		if( s_ditl )
		{
			DEBUGMESSAGE( "\"AskIfNewResolutionWorks\" DITL loaded." );
			DetachResource( s_ditl );
		}
		else
			DEBUGMESSAGE( "Error: Failed to load DITL." );
		
		OSStatus err = ResError();
		CHECKERR( err );
		if( err )
			DEBUGMESSAGE( "Found Resource Manager error # " << err << " after attempting to load the \"AskIfNewResolutionWorks\" DITL. " );	
	}
	return s_ditl;
}
Esempio n. 30
0
static ALCenum oss_open_capture(ALCdevice *device, const ALCchar *deviceName)
{
    int numFragmentsLogSize;
    int log2FragmentSize;
    unsigned int periods;
    audio_buf_info info;
    ALuint frameSize;
    int numChannels;
    oss_data *data;
    int ossFormat;
    int ossSpeed;
    char *err;

    if(!deviceName)
        deviceName = oss_device;
    else if(strcmp(deviceName, oss_device) != 0)
        return ALC_INVALID_VALUE;

    data = (oss_data*)calloc(1, sizeof(oss_data));
    data->killNow = 0;

    data->fd = open(oss_capture, O_RDONLY);
    if(data->fd == -1)
    {
        free(data);
        ERR("Could not open %s: %s\n", oss_capture, strerror(errno));
        return ALC_INVALID_VALUE;
    }

    switch(device->FmtType)
    {
        case DevFmtByte:
            ossFormat = AFMT_S8;
            break;
        case DevFmtUByte:
            ossFormat = AFMT_U8;
            break;
        case DevFmtShort:
            ossFormat = AFMT_S16_NE;
            break;
        case DevFmtUShort:
        case DevFmtInt:
        case DevFmtUInt:
        case DevFmtFloat:
            free(data);
            ERR("%s capture samples not supported\n", DevFmtTypeString(device->FmtType));
            return ALC_INVALID_VALUE;
    }

    periods = 4;
    numChannels = ChannelsFromDevFmt(device->FmtChans);
    frameSize = numChannels * BytesFromDevFmt(device->FmtType);
    ossSpeed = device->Frequency;
    log2FragmentSize = log2i(device->UpdateSize * device->NumUpdates *
                             frameSize / periods);

    /* according to the OSS spec, 16 bytes are the minimum */
    if (log2FragmentSize < 4)
        log2FragmentSize = 4;
    numFragmentsLogSize = (periods << 16) | log2FragmentSize;

#define CHECKERR(func) if((func) < 0) {                                       \
    err = #func;                                                              \
    goto err;                                                                 \
}
    CHECKERR(ioctl(data->fd, SNDCTL_DSP_SETFRAGMENT, &numFragmentsLogSize));
    CHECKERR(ioctl(data->fd, SNDCTL_DSP_SETFMT, &ossFormat));
    CHECKERR(ioctl(data->fd, SNDCTL_DSP_CHANNELS, &numChannels));
    CHECKERR(ioctl(data->fd, SNDCTL_DSP_SPEED, &ossSpeed));
    CHECKERR(ioctl(data->fd, SNDCTL_DSP_GETISPACE, &info));
    if(0)
    {
    err:
        ERR("%s failed: %s\n", err, strerror(errno));
        close(data->fd);
        free(data);
        return ALC_INVALID_VALUE;
    }
#undef CHECKERR

    if((int)ChannelsFromDevFmt(device->FmtChans) != numChannels)
    {
        ERR("Failed to set %s, got %d channels instead\n", DevFmtChannelsString(device->FmtChans), numChannels);
        close(data->fd);
        free(data);
        return ALC_INVALID_VALUE;
    }

    if(!((ossFormat == AFMT_S8 && device->FmtType == DevFmtByte) ||
         (ossFormat == AFMT_U8 && device->FmtType == DevFmtUByte) ||
         (ossFormat == AFMT_S16_NE && device->FmtType == DevFmtShort)))
    {
        ERR("Failed to set %s samples, got OSS format %#x\n", DevFmtTypeString(device->FmtType), ossFormat);
        close(data->fd);
        free(data);
        return ALC_INVALID_VALUE;
    }

    data->ring = CreateRingBuffer(frameSize, device->UpdateSize * device->NumUpdates);
    if(!data->ring)
    {
        ERR("Ring buffer create failed\n");
        close(data->fd);
        free(data);
        return ALC_OUT_OF_MEMORY;
    }

    data->data_size = info.fragsize;
    data->mix_data = calloc(1, data->data_size);

    device->ExtraData = data;
    data->thread = StartThread(OSSCaptureProc, device);
    if(data->thread == NULL)
    {
        device->ExtraData = NULL;
        free(data->mix_data);
        free(data);
        return ALC_OUT_OF_MEMORY;
    }

    device->szDeviceName = strdup(deviceName);
    return ALC_NO_ERROR;
}