/* call a callback function for each used channel */
BOOL
cm__chan_foreach(BOOL (*func)(), VOID *a1, VOID *a2)
{
INT n;
BOOL ret = TRUE;
D_LOG(D_ENTRY, ("cm__chan_foreach: entry, func: %lx, a1: 0x%lx, a2: 0x%lx", \
func, a1, a2));
for ( n = 0 ; n < MAX_CHAN_IN_SYSTEM ; n++ )
if ( chan_used[n] )
{
CM_CHAN *chan = chan_tbl + n;
D_LOG(D_ALWAYS, ("cm__chan_foreach: calling for chan# %d, channel: %lx", n, chan));
ret = (*func)(chan, a1, a2);
D_LOG(D_ALWAYS, ("cm__chan_foreach: returned %d", ret));
if ( !ret )
break;
}
return(ret);
}
/* find a matching listening connection */
CM*
cm__find_listen_conn(CHAR *lname, CHAR *rname, CHAR *addr, VOID *Idd)
{
CM *cm;
ULONG n;
D_LOG(D_ENTRY, ("cm__find_listen_conn: entry, lname: [%s], rname: [%s], addr: [%s]", \
lname, rname, addr));
/* scan connection table */
for ( n = 0; n < MAX_CM_IN_SYSTEM ; n++)
{
cm = cm_tbl[n];
if ( cm_used[n] && (cm->idd == Idd) && (cm->state == CM_ST_LISTEN) )
{
D_LOG(D_ENTRY, ("cm__find_listen_conn: comparing to: name: [%s], remote_name: [%s]", \
cm->dprof.name, cm->dprof.remote_name));
if ( cm__match_str(cm->dprof.name, rname) &&
cm__match_str(cm->dprof.remote_name, lname) )
return(cm);
}
}
return(NULL);
}
cl_int MemoryObjectWrapper::createSubBuffer (cl_mem_flags aFlags,
RegionWrapper const& aRegion,
MemoryObjectWrapper** aResultOut) {
#if CL_WRAPPER_CL_VERSION_SUPPORT >= 110
D_METHOD_START;
cl_int err = CL_SUCCESS;
VALIDATE_ARG_POINTER (aResultOut, &err, err);
cl_buffer_region region;
region.origin = aRegion.origin;
region.size = aRegion.size;
cl_mem mem = clCreateSubBuffer (mWrapped, aFlags, CL_BUFFER_CREATE_TYPE_REGION,
(void const*)®ion, &err);
if (err != CL_SUCCESS || !mem)
D_LOG (LOG_LEVEL_ERROR, "clCreateSubBuffer failed. (error %d)", err);
// NOTE: clCreateSubBuffer can return an existing handle.
*aResultOut = MemoryObjectWrapper::getNewOrExisting (mem);
return err;
#else // CL_WRAPPER_CL_VERSION_SUPPORT >= 110
(void)aFlags; (void)aRegion; (void)aResultOut;
D_LOG (LOG_LEVEL_ERROR, "CLWrapper support for OpenCL 1.1 API was not enabled at build time.");
return CL_INVALID_VALUE;
#endif
}
void
direct_trap( const char *domain, int sig )
{
sigval_t val;
if (direct_config->delay_trap_ms) {
D_LOG( Direct_Trap, VERBOSE, "NOT RAISING signal %d from %s, waiting for %dms... attach gdb --pid=%d\n", sig, domain, direct_config->delay_trap_ms, getpid() );
direct_thread_sleep( direct_config->delay_trap_ms * 1000LL );
return;
}
D_LOG( Direct_Trap, VERBOSE, "Raising signal %d from %s...\n", sig, domain );
val.sival_int = direct_gettid();
#ifndef DIRECT_BUILD_NO_SIGQUEUE
sigqueue( direct_gettid(), sig, val );
#endif
// direct_tgkill( direct_getpid(), direct_gettid(), sig );
D_LOG( Direct_Trap, VERBOSE, "...tgkill(%d) on ourself returned, maybe blocked, calling abort()!\n", sig );
abort();
D_LOG( Direct_Trap, VERBOSE, "...abort() returned as well, calling %s()!\n",
#ifdef __NR_exit_group
"exit_group" );
syscall( __NR_exit_group, DR_BUG );
#else
"_exit" );
_exit( DR_BUG );
#endif
}
/* add a channel to channel table */
mtl_add_chan(VOID *mtl_1, VOID *idd, USHORT bchan, ULONG speed, ULONG ConnectionType)
{
MTL *mtl = (MTL*)mtl_1;
INT ret = MTL_E_SUCC;
MTL_CHAN *chan;
INT n;
D_LOG(D_ENTRY, ("mtl_add_chan: entry, mtl: 0x%lx, idd: 0x%lx, bchan: %d, speed: 0x%x\n", \
mtl, idd, bchan, speed));
/* lock */
NdisAcquireSpinLock(&mtl->chan_tbl.lock);
/* check for space */
if ( mtl->chan_tbl.num >= MAX_CHAN_PER_CONN )
ret = MTL_E_NOROOM;
else
{
/* find free slot, MUST find! */
for ( chan = mtl->chan_tbl.tbl, n = 0 ; n < MAX_CHAN_PER_CONN ; n++, chan++ )
if ( !chan->idd )
break;
if ( n >= MAX_CHAN_PER_CONN )
{
D_LOG(DIGIMTL, ("mtl_add_chan: not free slot when num < MAX!\n"));
ret = MTL_E_NOROOM;
}
else
{
/* slot found, fill it */
mtl->chan_tbl.num++;
if (ConnectionType == CM_DKF)
{
mtl->IddTxFrameType = IDD_FRAME_DKF;
mtl->SendFramingBits = RAS_FRAMING;
}
else
{
mtl->IddTxFrameType = IDD_FRAME_PPP;
mtl->SendFramingBits = PPP_FRAMING;
}
chan->idd = idd;
chan->bchan = bchan;
chan->speed = speed;
chan->mtl = mtl;
/* add handler for slot */
idd_attach(idd, bchan, (VOID*)mtl__rx_bchan_handler, chan);
}
}
/* release & return */
NdisReleaseSpinLock(&mtl->chan_tbl.lock);
D_LOG(D_EXIT, ("mtl_add_chan: exit, ret: %d\n", ret));
return(ret);
}
/* do timer tick processing for rx side */
VOID
mtl__rx_tick(MTL *mtl)
{
INT n;
MTL_AS *as;
MTL_RX_TBL *RxTable = &mtl->rx_tbl;
//
// see if there are any receives to give to wrapper
//
IndicateRxToWrapper(mtl);
NdisAcquireSpinLock(&mtl->lock);
NdisAcquireSpinLock(&RxTable->lock);
/* scan assembly table */
for ( n = 0, as = RxTable->as_tbl ; n < MTL_RX_BUFS ; n++, as++ )
{
/* update ttl & check */
if ( as->tot && !(as->ttl -= 25) )
{
D_LOG(D_ALWAYS, ("mtl__rx_bchan_handler: Pkt Kill ttl = 0: Slot: %d, mtl: 0x%p", n, mtl));
D_LOG(D_ALWAYS, ("AS Timeout! mtl: 0x%p, as: 0x%p, as->seq: 0x%x", mtl, as, as->seq));
D_LOG(D_ALWAYS, ("as->tot: %d, as->num: %d", as->tot, as->num));
RxTable->TimeOutReceiveError1++;
//
// if this guy was queued for indication to wrapper
// and was not indicated within a second something is wrong
//
if (as->Queued)
{
D_LOG(D_ALWAYS, ("AS Timeout while queued for indication! mtl: 0x%p, as: 0x%p", mtl, as));
#if DBG
DbgBreakPoint();
#endif
}
as->tot = 0;
//
// mark this guy as being free
//
as->Queued = 0;
}
}
NdisReleaseSpinLock(&RxTable->lock);
NdisReleaseSpinLock(&mtl->lock);
}
/* get mac mtu on connection */
mtl_get_mac_mtu(VOID *mtl_1, ULONG *mtu)
{
MTL *mtl = (MTL*)mtl_1;
D_LOG(D_ENTRY, ("mtl_get_mac_mtu: entry, mtl: 0x%lx, @mtu: 0x%lx\n", mtl, mtu));
*mtu = MTL_MAC_MTU;
D_LOG(D_EXIT, ("mtl_get_mac_mtu: exit, mtu: %ld\n", *mtu));
return(MTL_E_SUCC);
}
/* handler for trace and dump area data packets */
VOID
trc__cmd_handler(VOID *idd_1, USHORT chan, ULONG Reserved, IDD_MSG *msg)
{
TRC *trc;
TRC_ENTRY *ent;
IDD *idd = (IDD*)idd_1;
D_LOG(D_ENTRY, ("trc__cmd_handler: idd: %lx, chan: %d, msg: %lx", \
idd, chan, msg));
D_LOG(D_ENTRY, ("trc__cmd_handler: opcode: 0x%x, buflen: 0x%x, bufptr: %lx", \
msg->opcode, msg->buflen, msg->bufptr));
D_LOG(D_ENTRY, ("trc__cmd_handler: bufid: %lx, param: 0x%x", \
msg->bufid, msg->param));
// Get the trace object for this idd
trc = idd_get_trc(idd);
// if no obect exit
if (trc == NULL || msg->bufid >= 2)
return;
/* if here it is a trace frame. param is rx/tx attribute */
/* establish entry to insert into & update vars */
/* check if trace enabled */
if ( trc->stat.state == TRC_ST_STOP )
return;
D_LOG(D_ALWAYS, ("trc__cmd_handler: trc: %lx", trc));
/* check if frame filters in */
if ( !trc__filter(trc->stat.filter, msg->bufptr, msg->buflen) )
return;
/* frames needs to be buffered, establish entry pointer */
ent = trc->ent_tbl + trc->ent_put;
trc->ent_put = (trc->ent_put + 1) % trc->stat.depth;
if ( trc->ent_num < trc->stat.depth )
trc->ent_num++;
/* fill up entry */
ent->seq = trc->ent_seq++;
KeQuerySystemTime(&ent->time_stamp);
ent->attr = msg->bufid;
ent->org_len = msg->buflen;
ent->len = MIN(msg->buflen, sizeof(ent->data));
IddGetDataFromAdapter(idd,
(PUCHAR)ent->data,
(PUCHAR)msg->bufptr,
(USHORT)ent->len);
// NdisMoveMemory (ent->data, msg->bufptr, ent->len);
}
static void
call_handlers( int num,
void *addr )
{
DirectLink *l, *n;
if (num == SIG_DUMP_STACK)
num = DIRECT_SIGNAL_DUMP_STACK;
/* Loop through all handlers. */
direct_mutex_lock( &handlers_lock );
direct_list_foreach_safe (l, n, handlers) {
DirectSignalHandler *handler = (DirectSignalHandler*) l;
if (handler->removed) {
direct_list_remove( &handlers, &handler->link );
D_MAGIC_CLEAR( handler );
D_FREE( handler );
continue;
}
D_LOG( Direct_Signals, FATAL, " --> %d\n", handler->num );
if (handler->num != num && handler->num != DIRECT_SIGNAL_ANY)
continue;
if (handler->num == DIRECT_SIGNAL_ANY && num == DIRECT_SIGNAL_DUMP_STACK)
continue;
switch (handler->func( num, addr, handler->ctx )) {
case DSHR_OK:
break;
case DSHR_REMOVE:
direct_list_remove( &handlers, &handler->link );
D_MAGIC_CLEAR( handler );
D_FREE( handler );
break;
case DSHR_RESUME:
D_LOG( Direct_Signals, FATAL, " '-> cured!\n" );
direct_mutex_unlock( &handlers_lock );
return;
default:
D_BUG( "unknown result" );
break;
}
}
cl_int EventWrapper::setUserEventStatus (cl_int aExecutionStatus) {
#if CL_WRAPPER_CL_VERSION_SUPPORT >= 110
D_METHOD_START;
cl_int err = clSetUserEventStatus (mWrapped, aExecutionStatus);
if (err != CL_SUCCESS) {
D_LOG (LOG_LEVEL_ERROR, " clSetUserEventStatus failed. (error %d)", err);
}
return err;
#else // CL_WRAPPER_CL_VERSION_SUPPORT >= 110
(void)aExecutionStatus;
D_LOG (LOG_LEVEL_ERROR, "CLWrapper support for OpenCL 1.1 API was not enabled at build time.");
return CL_INVALID_VALUE;
#endif
}
cl_int MemoryObjectWrapper::getGLObjectInfo (cl_gl_object_type *aGLObjectTypeOut,
cl_GLuint *aGLObjectNameOut) {
#ifdef CL_WRAPPER_ENABLE_OPENGL_SUPPORT
D_METHOD_START;
cl_int err = clGetGLObjectInfo (mWrapped, aGLObjectTypeOut, aGLObjectNameOut);
if (err != CL_SUCCESS)
D_LOG (LOG_LEVEL_ERROR, "clGetGLObjectInfo failed. (error %d)", err);
return err;
#else //CL_WRAPPER_ENABLE_OPENGL_SUPPORT
(void)aGLObjectTypeOut; (void)aGLObjectNameOut;
D_LOG (LOG_LEVEL_ERROR,
"CLWrapper support for OpenCL/OpenGL interoperability API was not enabled at build time.");
return CL_INVALID_VALUE;
#endif //CL_WRAPPER_ENABLE_OPENGL_SUPPORT
}
/* XXX: fix it to restore all registers */
void tlb_fill(CPUCRISState *env1, target_ulong addr, int is_write, int mmu_idx,
uintptr_t retaddr)
{
TranslationBlock *tb;
CPUCRISState *saved_env;
int ret;
saved_env = env;
env = env1;
D_LOG("%s pc=%x tpc=%x ra=%p\n", __func__,
env->pc, env->debug1, (void *)retaddr);
ret = cpu_cris_handle_mmu_fault(env, addr, is_write, mmu_idx);
if (unlikely(ret)) {
if (retaddr) {
/* now we have a real cpu fault */
tb = tb_find_pc(retaddr);
if (tb) {
/* the PC is inside the translated code. It means that we have
a virtual CPU fault */
cpu_restore_state(tb, env, retaddr);
/* Evaluate flags after retranslation. */
helper_top_evaluate_flags();
}
}
cpu_loop_exit(env);
}
env = saved_env;
}
/* free a channel */
VOID
cm__chan_free(CM_CHAN *chan)
{
D_LOG(D_ENTRY, ("cm__chan_free: entry, chan: 0x%lx", chan));
chan_used[chan - chan_tbl] = FALSE;
}
//
// Allocate free channel pool
//
VOID
ChannelInit(VOID)
{
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
/* allocate memory object */
NdisAllocateMemory((PVOID*)&chan_tbl, sizeof(CM_CHAN) * MAX_CHAN_IN_SYSTEM, 0, pa);
if ( chan_tbl == NULL )
{
D_LOG(D_ALWAYS, ("ChannelInit: memory allocate failed!"));
return;
}
D_LOG(D_ALWAYS, ("ChannelInit: chan_tbl: 0x%x", chan_tbl));
NdisZeroMemory (chan_tbl, sizeof(CM_CHAN) * MAX_CHAN_IN_SYSTEM);
NdisZeroMemory (chan_used, sizeof(chan_used));
}
/* XXX: fix it to restore all registers */
void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
{
TranslationBlock *tb;
CPUState *saved_env;
unsigned long pc;
int ret;
/* XXX: hack to restore env in all cases, even if not called from
generated code */
saved_env = env;
env = cpu_single_env;
D_LOG("%s pc=%x tpc=%x ra=%x\n", __func__,
env->pc, env->debug1, retaddr);
ret = cpu_cris_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
if (unlikely(ret)) {
if (retaddr) {
/* now we have a real cpu fault */
pc = (unsigned long)retaddr;
tb = tb_find_pc(pc);
if (tb) {
/* the PC is inside the translated code. It means that we have
a virtual CPU fault */
cpu_restore_state(tb, env, pc);
/* Evaluate flags after retranslation. */
helper_top_evaluate_flags();
}
}
cpu_loop_exit(env);
}
env = saved_env;
}
/* get connection speed, add channels from chan_tbl */
mtl_get_conn_speed(VOID *mtl_1, ULONG *speed)
{
MTL *mtl = (MTL*)mtl_1;
USHORT n;
D_LOG(D_ENTRY, ("mtl_get_conn_speed: entry, mtk: 0x%lx, @speed: 0x%lx\n", mtl, speed));
/* get lock, count, release */
NdisAcquireSpinLock(&mtl->chan_tbl.lock);
for ( n = 0, *speed = 0 ; n < mtl->chan_tbl.num ; n++ )
*speed += mtl->chan_tbl.tbl[n].speed;
NdisReleaseSpinLock(&mtl->chan_tbl.lock);
D_LOG(D_EXIT, ("mtl_get_conn_speed: exit, speed: %ld bps\n", *speed));
return(MTL_E_SUCC);
}
/* static */
nsresult WebCLKernel::getInstance (cl_kernel aInternal, WebCLKernel** aResultOut,
WebCL_LibCLWrapper* aLibWrapper)
{
nsresult rv = NS_OK;
WebCLKernel* existing = 0;
if (instanceRegistry.findById (aInternal, &existing))
{
NS_IF_ADDREF (*aResultOut = existing);
}
else
{
nsCOMPtr<WebCLKernel> obj = do_CreateInstance (WEBCL_KERNEL_CONTRACTID, &rv);
if (NS_FAILED (rv))
{
D_LOG (LOG_LEVEL_ERROR, "Failed to create instance. rv=%d.", rv);
return rv;
}
obj->setWrapper (aLibWrapper);
obj->mInternal = aInternal;
instanceRegistry.add (obj->mInternal, obj);
NS_IF_ADDREF (*aResultOut = obj);
}
return rv;
}
/* issue an element request to idp cm port */
INT
cm__elem_rq(VOID *idd, USHORT port, CHAR *elem_buf, USHORT elem_len)
{
IDD_MSG msg;
CHAR *p;
D_LOG(D_ENTRY|DIGIQ931, ("cm__elem_rq: entry, idd: 0x%lx, port: 0x%d, elem_buf: 0x%lx, elem_len: 0x%d\n", \
idd, port, elem_buf, elem_len));
/* clear outgoing message */
NdisZeroMemory(&msg, sizeof(msg));
/* allocate a local buffer */
if ( !(msg.bufptr = p = ut_get_buf()) )
return(CM_E_NOMEM);
/* copy buffer */
adv_ptr(p, elem_buf, (INT)elem_len);
/* fillin message structure */
msg.opcode = Q931_ELEM_RQ;
msg.buflen = p - msg.bufptr;
/* send to idd */
if ( idd_send_msg(idd, &msg, port,
(VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC )
{
ut_free_buf(msg.bufptr);
return(CM_E_IDD);
}
return(CM_E_SUCC);
}
/* control data transfer on a bchannel */
INT
cm__bchan_ctrl_comp(CM_CHAN *chan, ULONG CompressionFlag)
{
IDD_MSG msg;
USHORT Enable = 0;
D_LOG(D_ENTRY|DIGIQ931, ("cm__bchan_ctrl_comp: entry, chan: 0x%lx, state: %d\n", \
chan, CompressionFlag));
/* channel must be assigned */
if ( !CM_BCHAN_ASSIGNED(chan->bchan) )
return(CM_E_BADCHAN);
/* map channel type to operation */
if ( CompressionFlag )
Enable = COMP_TX_ENA | COMP_RX_ENA;
/* build msg */
NdisZeroMemory(&msg, sizeof(msg));
msg.opcode = CMD_COMPRESS;
msg.bufid = MAKELONG( chan->bchan | ( Enable << 8 ), 0);
/* send it */
idd_send_msg(chan->idd, &msg, IDD_PORT_CMD_TX, NULL, NULL);
return(CM_E_SUCC);
}
/* format a disconenct request */
INT
cm__disc_rq(CM_CHAN *chan)
{
IDD_MSG msg;
D_LOG(D_ENTRY|DIGIQ931, ("cm__disc_rq: entry, chan: 0x%lx\n", chan));
/* clear outgoing message */
NdisZeroMemory(&msg, sizeof(msg));
/* fillin message structure */
msg.opcode = Q931_REL_RQ;
msg.bufid = MAKELONG(0, chan->cid);
msg.bufptr = ut_get_buf();
msg.buflen = 0;
/* send to idd */
if (idd_send_msg(chan->idd, &msg, (USHORT)CM_PORT(chan), (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC)
ut_free_buf(msg.bufptr);
/* turn off channel */
cm__bchan_ctrl(chan, 0);
return(CM_E_SUCC);
}
/* format a call ignore response */
INT
cm__est_ignore(
PVOID idd,
USHORT cid,
USHORT lterm)
{
IDD_MSG msg;
D_LOG(D_ENTRY|DIGIQ931, ("cm__est_ignore: entry, idd: 0x%lx, cid: 0x%x, lterm: 0x%x\n", idd, cid, lterm));
/* clear outgoing message */
NdisZeroMemory(&msg, sizeof(msg));
/* fillin message structure */
msg.opcode = Q931_EST_IGNORE;
msg.bufid = MAKELONG(0, cid);
msg.bufptr = ut_get_buf();
msg.buflen = 0;
/* send to idd */
if (idd_send_msg(idd, &msg, (USHORT)(lterm + IDD_PORT_CM0_TX), (VOID*)cm__q931_cmpl_handler, NULL) != IDD_E_SUCC)
ut_free_buf(msg.bufptr);
return(CM_E_SUCC);
}
/* static */
nsresult WebCLSampler::getInstance (cl_sampler aInternal, WebCLSampler** aResultOut,
WebCL_LibCLWrapper* aLibWrapper)
{
nsresult rv = NS_OK;
WebCLSampler* existing = 0;
if (instanceRegistry.findById (aInternal, &existing))
{
NS_IF_ADDREF (*aResultOut = existing);
}
else
{
nsCOMPtr<WebCLSampler> obj ( new WebCLSampler () );
if (!obj)
{
D_LOG (LOG_LEVEL_ERROR, "Failed to create instance. rv=%d.", rv);
return NS_ERROR_OUT_OF_MEMORY;
}
obj->setWrapper (aLibWrapper);
obj->mInternal = aInternal;
instanceRegistry.add (obj->mInternal, obj);
NS_IF_ADDREF (*aResultOut = obj);
}
return rv;
}
/* set connection state */
mtl_set_conn_state(
VOID *mtl_1,
USHORT NumberOfChannels,
BOOL is_conn)
{
MTL *mtl = (MTL*)mtl_1;
ADAPTER *Adapter = mtl->Adapter;
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(0xffffffff, 0xffffffff);
D_LOG(D_ENTRY, ("mtl_set_conn_state: entry, is_conn: %d\n", is_conn));
/* get lock, set, release & return */
NdisAcquireSpinLock(&mtl->lock);
mtl->is_conn = is_conn;
//
// if we are being notified of a new connection we need to do some stuff
//
if (is_conn)
{
mtl->FramesXmitted = 0;
mtl->FramesReceived = 0;
mtl->BytesXmitted = 0;
mtl->BytesReceived = 0;
mtl->RecvFramingBits = 0;
mtl->tx_tbl.NextFree = 0;
mtl->rx_tbl.NextFree = 0;
}
NdisReleaseSpinLock(&mtl->lock);
return(MTL_E_SUCC);
}
void Palette::PresetApply(PalettePreset &preset)
{
static const U16 b_arr[] = { 0, 1, 3, 0, 0, 1, 3, 0, 0, 1, 3, 0, 0, 1, 3 };
static const U16 r_arr[] = { 0, 0, 0, 1, 3, 1, 3, 0, 0, 0, 0, 1, 3, 1, 3 };
static const U16 g_arr[] = { 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 3, 1, 3, 1, 3 };
const auto &coeffs = preset.CoeffsGet();
const U16 brights[] = { coeffs.zz, coeffs.zn, coeffs.nn, coeffs.zb, coeffs.nb, 0 /*dummy*/, coeffs.bb };
U16 r, g, b;
U16 tr, tg, tb;
D_LOG(D_DEBUG, D_LOG_MSG("Apply palette preset: %s", CSTR(preset.NameGet())));
clear();
for (auto row = 0; row < PALETTE_ROWS; ++row) {
for (auto col = row; col < PALETTE_COLUMS; ++col) {
b = brights[b_arr[row] + b_arr[col]];
r = brights[r_arr[row] + r_arr[col]];
g = brights[g_arr[row] + g_arr[col]];
tr = ((r * coeffs.r11) + (g * coeffs.g12) + (b * coeffs.b13)) / (U16)0x100;
tg = ((r * coeffs.r21) + (g * coeffs.g22) + (b * coeffs.b23)) / (U16)0x100;
tb = ((r * coeffs.r31) + (g * coeffs.g32) + (b * coeffs.b33)) / (U16)0x100;
const PaletteItem item(tr, tg, tb);
if (TRUE != IsDuplicate(item)) { // Filter duplicate colors.
append(item);
//D_LOG(D_DEBUG, D_LOG_MSG("row=%i,\tcol=%i,\tr=%i,\tg=%i,\tb=%i", row, col, tr, tg, tb));
}
}
}
}
/* nsIVariant getSamplerInfo (in long aName); */
NS_IMETHODIMP WebCLSampler::GetSamplerInfo(PRInt32 aName, JSContext *cx, nsIVariant **_retval)
{
D_METHOD_START;
NS_ENSURE_ARG_POINTER (_retval);
nsresult rv;
cl_int err = CL_SUCCESS;
int type = getTypeForInfoName (aName);
if (type == types::UNKNOWN)
{
D_LOG (LOG_LEVEL_ERROR, "Info parameter name %d does not have a known type.", aName);
WebCL_reportJSError (cx, "Info name %d is not supported by %s.",
aName, __FUNCTION__);
return WEBCL_XPCOM_ERROR; //NS_ERROR_FAILURE;
}
nsCOMPtr<nsIWritableVariant> variant = do_CreateInstance(NS_VARIANT_CONTRACTID, &rv);
NS_ENSURE_SUCCESS (rv, rv);
WEBCL_GETINFO_MEDIATOR_SWITCH (aName, type, mWrapper, getSamplerInfo, mInternal,
variant, err, rv);
NS_ADDREF (*_retval = variant);
return NS_OK;
}
/* get an entry by sequence number */
INT
trc_get_entry(VOID *trc_1, ULONG seq, TRC_ENTRY *ent)
{
TRC *trc = (TRC*)trc_1;
ULONG n, index;
D_LOG(D_ENTRY, ("trc_get_entry: entry, trc: 0x%lx, seq: %ld, ent: 0x%lx", \
trc, seq, ent));
// if no obect exit
if (trc == NULL)
return(TRC_E_NOSUCH);
/* find requested sequence number, temp!!!, using search! */
for ( n = 0 ; n < trc->ent_num ; n++ )
{
index = (trc->ent_get + n) % trc->stat.depth;
if ( trc->ent_tbl[index].seq == seq )
{
/* found */
*ent = trc->ent_tbl[index];
return(TRC_E_SUCC);
}
}
/* if here not found */
return(TRC_E_NOSUCH);
}
static bool
show_segv( const siginfo_t *info, ucontext_t *uctx )
{
switch (info->si_code) {
#ifdef SEGV_MAPERR
case SEGV_MAPERR:
D_LOG( Direct_Signals, FATAL, " --> Caught signal %d (at %p, invalid address) <--\n", info->si_signo, info->si_addr );
return true;
#endif
#ifdef SEGV_ACCERR
case SEGV_ACCERR:
D_LOG( Direct_Signals, FATAL, " --> Caught signal %d (at %p, invalid permissions) <--\n", info->si_signo, info->si_addr );
return true;
#endif
}
return false;
}
/* filter trace frame */
INT
trc__filter(ULONG filter, CHAR *buf, ULONG len)
{
D_LOG(D_ENTRY, ("trc__filter: entry, filter: %ld, buf: 0x%lx, len: %ld",\
filter, buf, len));
/* not implemented, all frames filter in */
return(1);
}
/* completion handler for q931 command with attached local buffers */
VOID
cm__q931_cmpl_handler(VOID *arg, USHORT port, IDD_MSG *msg)
{
D_LOG(D_ENTRY|DIGIQ931, ("cm__q931_cmpl_handler: arg: 0x%lx, port: 0x%d, msg: 0x%lx\n", \
arg, port, msg));
/* free attached buffer */
ut_free_buf(msg->bufptr);
}
/* initialize support */
INT
res_init(VOID)
{
NDIS_PHYSICAL_ADDRESS pa = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
/* allocate memory object */
NdisAllocateMemory((PVOID*)&res__tbl, (sizeof(RES) * MAX_RES), 0, pa);
if ( !res__tbl )
{
D_LOG(D_ALWAYS, ("res_init: memory allocate failed!"));
return(RES_E_NOMEM);
}
D_LOG(D_ALWAYS, ("res_init: res__tbl: 0x%lx", res__tbl));
NdisZeroMemory (res__tbl, sizeof(RES) * MAX_RES);
// NdisAllocateSpinLock(&res__lock);
return(RES_E_SUCC);
}
