自学教程：C++ DERROR函数代码示例

intclient_writen(int fd, char *buf, size_t datalen, int timeout){    size_t nleft;    ssize_t nwritten;    const char *ptr;    ptr = buf;    nleft = datalen;    while (nleft > 0) {        if (timeout > 0 && timeout_wait(fd, timeout, 0) == -1) {            DERROR("write timeout/n");            break;        }        if ((nwritten = write(fd, ptr, nleft)) <= 0) {            if (nwritten < 0 && errno == EINTR) {                nwritten = 0;            } else {                DERROR("writen error: %s/n", strerror(errno));                return -1;            }        }        nleft -= nwritten;        ptr += nwritten;    }    return datalen-nleft;}

bool CDisplayPlane::Create(void){  DENTRY();  m_lock = g_pIOS->CreateResourceLock();  if(!m_lock)  {    DERROR("failed to allocate resource lock/n");    return false;  }  DEBUGF2(2,("%s: node entries = %lu /n",__PRETTY_FUNCTION__,m_ulNodeEntries));  g_pIOS->AllocateDMAArea(&m_NodeListArea, (m_ulNodeEntries * sizeof(stm_plane_node)), 0, SDAAF_NONE);  g_pIOS->MemsetDMAArea(&m_NodeListArea, 0, 0, m_NodeListArea.ulDataSize);  if(!m_NodeListArea.pMemory)  {    DERROR("failed to allocate node list/n");    return false;  }  m_pNodeList = (stm_plane_node*)m_NodeListArea.pData;  DEXIT();  return true;}

void GEnv::setState(SoundCompEvent* e){    DASSERT(e!=NULL);    if(e->empty())return;    if(e->getSize()!=sizeof(State))    {        DERROR("size missmatch");        if(e->getSize() < sizeof(State))return;	        DERROR("trying to read...");    }    const State* s = (const State*)e->getData();       mode->setValue(s->mode);       if(mode->isPressed())    {        sig->setMode(EnvFollow::RMS);    }    else    {        sig->setMode(EnvFollow::PEAK);    }       per_knob->setValue(s->per);    updatePer();}

/*** @brief 		SD polling stataus function when send data.* @param 		device_id[in]: Index of SD controller.* @param 		pollbit[in]: Polling status bit.* @return		SP_TRUE: success, SP_FALSE: timeout or status fail.*/SP_BOOL WaitSDStatus_Data(	UINT32 device_id,	UINT32 pollbit){	sdReg_t *psdReg = (sdReg_t*) SetSDBase(device_id);	UINT32 init = jiffies; 	do	{		/* ----- SD status error ----- */		if (psdReg->sdStatus & MASK_S_DataCRCError) 		{			DERROR("data SD%d CRC error, CMD = 0x%x, STATUS = 0x%x/n", device_id, psdReg->sdCmd, psdReg->sdStatus);			return SP_FALSE;		}		/* ----- Timeout ----- */		if((jiffies-init)>=DATA_TIMEOUT)		{			DERROR("data SD%d timeout, CMD = 0x%x, STATUS = 0x%x/n", device_id, psdReg->sdCmd, psdReg->sdStatus);			return SP_FALSE;		}	} while((psdReg->sdStatus & pollbit)!=pollbit);		return SP_TRUE;}

int test_sl_range(TestArgs *args){    MemLink *m;    int ret, i;    DINFO("====== sl_range ======/n");    if (args->longconn) {        m = memlink_create(args->host, args->rport, args->wport, args->timeout);        if (NULL == m) {            DERROR("memlink_create error!/n");            exit(-1);            return -1;        }        for (i = 0; i < args->testcount; i++) {            MemLinkResult   result;            ret = memlink_cmd_rpop(m, args->table, args->key, args->len, &result);            if (ret != MEMLINK_OK) {                DERROR("range error! ret:%d/n", ret);                return -2;            }            if (result.count != args->len) {                DERROR("rpop result count error: %d, len:%d/n", result.count, args->len);            }            memlink_result_free(&result);        }        memlink_destroy(m);    } else {    }    return 0;}

// execute dialog in a child process, leave it running///////////////////////////////////////////////////////////////////////////////////////////pid_t sdialog_call(const char* path,const char* msg){    pid_t pid;	DPRINTF("sdialog_call/fork/n");    if((pid=fork())<0)	{		DERROR("sdialog_call/fork");        return 0L;    }    if(pid==0)	{		DPRINTF("sdialog_call: in child/n");		DPRINTF("sdialog_call: DISPLAY=%s/n",getenv("DISPLAY"));       	umask(0);		chdir("/");		DPRINTF("call_dialog: about to exec %s/n",path);		execlp(path,path,msg,(char*)0);		DERROR("sdialog_call/execlp");		exit(1);    }	DPRINTF("sdialog_call: child PID=%d/n",pid);    return pid;}

intclient_readn(int fd, char *buf, int datalen, int timeout){    size_t nleft;    ssize_t nread;    char *ptr;    ptr = buf;    nleft = datalen;    while (nleft > 0) {        if (timeout > 0 && timeout_wait(fd, timeout, 1) == -1) {            DERROR("read timeout/n");            break;        }        if ((nread = read(fd, ptr, nleft)) == -1) {            if (errno == EINTR) {                nread = 0;            } else {                DERROR("readn error: %s/n", strerror(errno));                return -1;            }        } else if (nread == 0) {            DERROR("read 0, conn cloes/n");            break;        }        nleft -= nread;        ptr += nread;    }    return datalen-nleft;}

//备切换成主int switch_master(int voteid, char *data, int datalen){    WThread    *wt = g_runtime->wthread;    MasterInfo *minfo = wt->master_info;    if (g_cf->role == ROLE_MASTER) {        DERROR("master can not switch to master/n");        return -1;    } else if (g_cf->role == ROLE_BACKUP) {        DINFO("backup switch to master/n");        if (minfo != NULL) {            //销毁备上面以前保存得主节点得信息            event_del(&minfo->hb_timer_evt);            event_del(&minfo->hbevt);            if (minfo->hbsock > 0)                close(minfo->hbsock);            minfo->hbsock = -1;            wt->master_info = NULL;                        zz_free(minfo);            //构建主节点上得备节点信息            master_init(voteid, data, datalen);            if (wt->clog->state == INCOMPLETE) {                int ret;                int cmdlen;                char *cmd = commitlog_get_cmd(wt->clog, &cmdlen);                pthread_mutex_lock(&g_runtime->mutex);                ret = wdata_apply(cmd, cmdlen, MEMLINK_NO_LOG, NULL);                DINFO("===wdata_apply ret: %d/n", ret);                if ( ret == 0) {                    int sret;                    sret = synclog_write(g_runtime->synclog, wt->clog->data, wt->clog->len);                    if (sret < 0) {                        DERROR("synclog_write error: %d/n", sret);                        MEMLINK_EXIT;                    }                       char *cmd;                    int  cmdlen;                    cmd = commitlog_get_cmd(wt->clog, &cmdlen);                    sret = syncmem_write(g_runtime->syncmem, cmd, cmdlen,                         g_runtime->synclog->version, g_runtime->synclog->index_pos - 1);                     if (sret < 0) {                        DERROR("syncmem_write error: %d/n", sret);                        MEMLINK_EXIT;                    }                   }                pthread_mutex_unlock(&g_runtime->mutex);            }        } else {            DERROR("master info is null, can not switch/n");            return -3;        }    }    return 0; }

int storage_license_check(){        int ret, now, retry = 0, free_limit = 0;        long capacity;        uint32_t createtime;	struct stat buf;        char license[MAX_PATH_LEN];#if 0        return 0;#endif	if (cluster_is_solomode())		return 0;retry:        ret = storage_get_createtime(&createtime);        if (ret) {                if (ret == EAGAIN) {                        SLEEP_RETRY(err_ret, ret, retry, retry);                } else                        GOTO(err_ret, ret);        }        now = time(NULL);        snprintf(license, MAX_PATH_LEN, "%s/license", gloconf.home);        ret = stat(license, &buf);        if (!ret) {                if ((buf.st_size == 0) && (now - createtime <= FREE_LICENSE)) {                        return 0;                }        }        ret = license_check(gloconf.home, &capacity, free_limit);        if (ret) {                if (ret == ENOENT) {                        if (now - createtime > FREE_LICENSE) {                                DERROR("No license found./n");                        }                        else                                return 0;                } else if (ret == ETIME) {                        DERROR("License expired./n");                } else if (ret == ENOSPC) {                        DERROR("Excess capacity./n");                } else {                        DERROR("Invalid license./n");                }                exit(EACCES);        }        return 0;err_ret:        return ret;}

/* mark interrupt slot as unused, close descriptor if all slots are unused */void _smi_free_int_scidesc(smi_sci_desc_t* pDesc, sci_error_t* pError) {      smi_sci_desc_list_t* pTemp;        SMI_LOCK(&sdMutex);        pTemp = **pDesc;       switch(pTemp->ltype) {    case sd_rmtlocfree:	/* descriptor becomes unused => will be completely removed */	sd_node_remove(*pDesc);	rs_SCIClose(pTemp->sd,0,pError);	free(pTemp);		break;    case sd_locintfree:    case sd_rmtintfree:    case sd_intfree:	DERROR("internal list-structure error");	SMI_Abort(-1);	break;    case sd_full:	/* descriptor now has a free interrupt slot */	sd_node_remove(*pDesc);	pTemp->ltype = sd_intfree;	pTemp->pIntRef = NULL;		sd_node_push_front(&pIntListRoot, pTemp);	*pError = SCI_ERR_OK;	break;    case sd_locfree:	/* descriptor now has a free interrupt and local slot */	sd_node_remove(*pDesc);	pTemp->ltype = sd_locintfree;	pTemp->pIntRef = NULL;		sd_node_push_front(&pLocIntListRoot, pTemp);	*pError = SCI_ERR_OK;	break;    case sd_rmtfree:	/* descriptor now has a free interrupt and remote slot */	sd_node_remove(*pDesc);	pTemp->ltype = sd_rmtintfree;	pTemp->pIntRef = NULL;		sd_node_push_front(&pRmtIntListRoot, pTemp);	*pError = SCI_ERR_OK;	break;    default:       	DERROR("internal list-structure error (invalid type)");	SMI_Abort(-1);    }    /* invalidate the given descriptor */    *pDesc = NULL;    SMI_UNLOCK(&sdMutex);}

/*** @brief 	SD card write function with scatter list.* @param 	sd[in]: Card information.* @param 	sector[in]: Start sector.* @param 	sg[in]: Scatter list pointer.* @param 	ln[in]: List number.* @return 	Actual sectors by reading/ERROR_ID(<0).*/int gp_sdcard_write_scatter(gpSDInfo_t * sd, unsigned int sector, struct scatterlist *sg, unsigned int ln){	int i;	struct scatterlist *sg_ev;	int ret = 0;	int sector_num = 0;#ifdef USE_DMA		unsigned sgln;	sgln = dma_map_sg(NULL, sg, ln, DMA_TO_DEVICE);	if(sgln!=ln)	{		dma_unmap_sg(NULL, sg, sgln, DMA_TO_DEVICE);		DERROR("[%d]: SG map fail, sgln = %d, ln = %d/n", sd->device_id, sgln, ln);		return -ENOMEM;	}#endif		if(gp_sdcard_writecmd(sd->device_id,sector)==SP_FALSE)	{		ret = -EIO;		goto out_error;	}	DEBUG("SD: write sector %d/n", sector);		for_each_sg(sg, sg_ev, ln, i) 	{		unsigned int number = sg_dma_len(sg_ev)>>9;		/* ----- Start dma ----- */ 	#ifdef USE_DMA		if(gp_sdcard_dma_en(sd->device_id, (unsigned char*)sg_phys(sg_ev), sg_dma_len(sg_ev),1)==SP_FALSE)	#else		if(gp_sdcard_dma_en(sd->device_id, (unsigned char*)sg_virt(sg_ev), sg_dma_len(sg_ev),1)==SP_FALSE)	#endif		{			ret = -ENOMEM;			DERROR("[%d]:DMA Enable error/n", sd->device_id);			goto out_error;		}		/* ----- Wait dma finish ----- */		ret = gp_sdcard_dma_finish(sd->device_id, (sg_dma_len(sg_ev)>>9)*WRITE_TIMEOUT);		if(ret!=0)		{			gp_apbdma0_stop(sd->handle_dma);			DERROR("[%d]:DMA error: %d, SD status 0x%x/n", sd->device_id, ret,gpHalSDGetStatus(sd->device_id));			goto out_error;		}	#ifdef USE_DMA			if(gpHalSDWaitDataComplete(sd->device_id) == SP_FALSE)		{			DERROR("[%d]: wait complete error: SD status 0x%x/n", sd->device_id, gpHalSDGetStatus(sd->device_id));			ret = -ETIMEDOUT;			goto out_error;		}	#endif		sector_num += number;	}

intmaster_init(int voteid, char *data, int datalen){    int ret;    WThread *wt = g_runtime->wthread;        wt->clog = commitlog_create();    g_cf->role = ROLE_MASTER;        wt->backup_info = (BackupInfo *)zz_malloc(sizeof(BackupInfo));        DNOTE("============I am the master/n");    if (wt->backup_info == NULL) {        DERROR("malloc BackupInfo struct error/n");        MEMLINK_EXIT;    }    memset(wt->backup_info, 0x0, sizeof(BackupInfo));    BackupInfo *binfo = wt->backup_info;    g_runtime->servernums = 1;    g_runtime->voteid = voteid;    binfo->timer_send = FALSE;    int  count = 0;    char ip[16] = {0};    uint16_t port;    DINFO("datalen : %d/n", datalen);    while (count < datalen) {        ret = unpack_votehost(data + count, ip, &port);        DINFO("ip: %s port: %d/n", ip, port);        count += ret;        BackupItem *bitem = (BackupItem *)zz_malloc(sizeof(BackupItem));        if (bitem == NULL) {            DERROR("malloc BackupItem struct error/n");            MEMLINK_EXIT;        }        memset(bitem, 0x0, sizeof(BackupItem));        strcpy(bitem->ip, ip);        bitem->write_port = port;        DINFO("backup ip, port: %s:%d/n", ip, port);        bitem->next = binfo->item;        binfo->item = bitem;        g_runtime->servernums++;    }    master_create_heartbeat(wt);    //初始化backupinfo结构    ret = master_connect_backup_all(wt);    return 0;}

int test_move(TestArgs *args){    MemLink *m;    int ret, i;    char value[512] = {0};    int valint = atoi(args->value);    char format[64];    DINFO("====== move ======/n");    sprintf(format, "%%0%dd", args->valuesize);    if (args->longconn) {        m = memlink_create(args->host, args->rport, args->wport, args->timeout);        if (NULL == m) {            DERROR("memlink_create error!/n");            exit(-1);            return -1;        }        for (i = 0; i < args->testcount; i++) {            sprintf(value, format, valint);            ret = memlink_cmd_move(m, args->table, args->key, value, args->valuesize, args->pos);            if (ret != MEMLINK_OK) {                DERROR("move error! ret:%d, table:%s key:%s,value:%s,pos:%d/n",                       ret, args->table, args->key, value, args->pos);                return -2;            }            valint++;        }        memlink_destroy(m);    } else {        for (i = 0; i < args->testcount; i++) {            m = memlink_create(args->host, args->rport, args->wport, args->timeout);            if (NULL == m) {                DERROR("memlink_create error!/n");                exit(-1);                return -1;            }            sprintf(value, format, valint);            ret = memlink_cmd_move(m, args->table, args->key, value, args->valuesize, args->pos);            if (ret != MEMLINK_OK) {                DERROR("move error! ret:%d, table:%s key:%s,value:%s,pos:%d/n",                       ret, args->table, args->key, value, args->pos);                return -2;            }            valint++;            memlink_destroy(m);        }    }    return 0;}

voidvote_destroy(Conn *conn){    VoteConn *vconn = (VoteConn *)conn;    if (conn->rbuf)        zz_free(conn->rbuf);    event_del(&conn->evt);    set_linger(conn->sock);    close(conn->sock);    if (vconn->vote_status == VOTE_TIMEOUT) {        DERROR("*** VOTE TIMEOUT, TRY AGAIN/n");        vconn->vote_status = VOTE_CONTINUE;    } else if (vconn->vote_status == VOTE_REQUEST || vconn->vote_status == VOTE_WAITING) {        /*                if (g_cf->role == ROLE_NONE) {                    DERROR("*** VOTE REQUEST TRY AGAIN/n");                    vconn->status = VOTE_CONTINUE;                } else {        */        DERROR("*** VOTE ABNORMAL ERROR/HOST INVALID/n");        vconn->vote_status = VOTE_CONTINUE;        /*                    g_cf->role = ROLE_NONE;                    g_runtime->voteid = 0;                    zz_free(vconn);                    return;                }        */    } else if (vconn->vote_status == VOTE_ERR_PARAM) {        DERROR("*** VOTE PARAM ERROR/n");        g_cf->role = ROLE_NONE;        g_runtime->voteid = 0;        zz_free(vconn);        return;    }    if (vconn->vote_status == VOTE_CONTINUE) {        DINFO("*** VOTE CONTINUE/n");        request_vote(vconn->id, vconn->idflag, vconn->voteid, vconn->wport);        zz_free(vconn);        return;    }    DINFO("*** VOTE OK/n");    zz_free(vconn);}

int main(int argc, char **argv){#ifdef DEBUG    logfile_create("test.log", 3);#endif    char *conffile = "memlink.conf";    MemPool *mp;    MemItem *item_100;    MemItem *item_10;    myconfig_create(conffile);    my_runtime_create_common("memlink");    mp = g_runtime->mpool;    item_100 = (MemItem *)zz_malloc(sizeof(MemItem));    memset(item_100, 0x0, sizeof(MemItem));    item_10 = (MemItem *)zz_malloc(sizeof(MemItem));    memset(item_10, 0x0, sizeof(MemItem));    DataBlock *dbk;    int i;    for (i = 0; i < 100; i++) {        dbk = mempool_get(mp, 100 + sizeof(DataBlock));        dbk->next = item_100->data;        item_100->data = dbk;    }    for (i = 0; i < mp->used; i++) {        if (mp->freemem[i].memsize == 100 + sizeof(DataBlock)) {            break;        }    }    if (i == mp->used) {        DERROR("i == mp->used/n");         return -1;    }    if (mp->freemem[i].total != 100) {        DERROR("mp->freemem[i].total != 100/n");        return -1;    }    if (mp->freemem[i].block_count != 0) {        DERROR("mp->freemem[i].block_count != 0/n");        return -1;    }    return 0;}

int tcp_socket_server(char *host, int port){    int fd;    int ret;    fd = socket(AF_INET, SOCK_STREAM, 0);    if (fd == -1) {        char errbuf[1024];        strerror_r(errno, errbuf, 1024);        DERROR("create socket error: %s/n",  errbuf);        return -1;    }    tcp_server_setopt(fd);        struct sockaddr_in  sin;    sin.sin_family = AF_INET;    sin.sin_port = htons((short)port);    if (host) {        sin.sin_addr.s_addr = inet_addr(host);    }else{        sin.sin_addr.s_addr = htonl(INADDR_ANY);    }    memset(&(sin.sin_zero), 0, sizeof(sin.sin_zero));     DINFO("bind to: %d/n", port);    ret = bind(fd, (struct sockaddr*)&sin, sizeof(sin));    if (ret == -1) {        char errbuf[1024];        strerror_r(errno, errbuf, 1024);        DERROR("bind error: %s/n",  errbuf);        close(fd);        return -1;    }    ret = listen(fd, 128);    if (ret == -1) {        char errbuf[1024];        strerror_r(errno, errbuf, 1024);        DERROR("listen error: %s/n",  errbuf);        close(fd);        return -1;    }    return fd;}

/*** @brief 		SD polling stataus function when send command.* @param 		device_id[in]: Index of SD controller.* @param 		pollbit[in]: Polling status bit.* @return		SP_TRUE: success, SP_FALSE: timeout or status fail.*/static SP_BOOL WaitSDStatus(	UINT32 device_id,	UINT32 pollbit){	sdReg_t *psdReg = (sdReg_t*) SetSDBase(device_id);	UINT32 init = jiffies;		do	{		/* ----- SD status error ----- */		if (psdReg->sdStatus & (MASK_S_RespIdxError|MASK_S_RespCRCError|MASK_S_TimeOut)) 		{			DEBUG("cmd SD%d, CMD = 0x%x, STATUS = 0x%x/n", device_id, psdReg->sdCmd, psdReg->sdStatus);			return SP_FALSE;		}		/* ----- Timeout ----- */		if((jiffies-init)>=COMMAND_TIMEOUT)		{			DERROR("cmd SD%d timeout [t:%d], CMD = 0x%x, STATUS = 0x%x/n", device_id, (jiffies-init), psdReg->sdCmd, psdReg->sdStatus);			return SP_FALSE;		}	}while((psdReg->sdStatus & pollbit)!=pollbit);		return SP_TRUE;}

/*** @brief 	Check SD card status function by CMD13.* @param	sd[in]: Card information.* @return 	SUCCESS/ERROR_ID.*/ int gp_sdcard_get_status(gpSDInfo_t * sd){	unsigned int response = 0;	if(gpHalSDSendCmd(sd->device_id, SD_CMD13, sd->RCA, &response, 4)==SP_FALSE)	{		DERROR("[%d]: CMD13 fail/n", sd->device_id);		return -EIO;	}	/* ----- Check response error bit ----- */	if(gp_sdcard_ch_resp(response))	{		DERROR("[%d]: resp = %d error/n", response );		return -EINVAL;	}		return 0;}

bool ProgramState::dumpToFile(){    if(!runningDump())    {        DERROR("not running dump");        return false;    }       Wav w;    w.make(wavdump->getBytes(),dumpoff*2 /*bytes*/,getSampleRate(),nchan,16);       string fname = running_dump_name;    DASSERT(fname.size()>0);       w.save(fname,true);    cout << "wrote: " << fname.c_str() << endl;    w.del();       delete wavdump;    wavdump=NULL;    dumplen=0;       return true;   }

/*** @brief 	Scatter list data  transfer function.* @param 	sd[in]: Card information.* @param 	sector[in]: Start sector.* @param 	sg[in]: Scatter list pointer.* @param 	ln[in]: List number.* @return 	Actual sectors by reading/ERROR_ID(<0).*/ static int gp_sdcard_transfer_scatter(gpSDInfo_t *sd, unsigned long sector, struct scatterlist *sg, unsigned int ln, int write){	int ret;	int pin_handle;	/* ----- Check card status ----- */	if((gp_sdcard_ckinsert(sd)==0)||(sd->handle_dma==0))		return -ENXIO;	/* ----- Get pin handle ----- */	pin_handle = gp_board_pin_func_request((sd->device_id==0)?GP_PIN_SD0:GP_PIN_SD1, GP_BOARD_WAIT_FOREVER);	if(pin_handle<0)	{		DERROR("SD%d: can't get pin handle/n", sd->device_id);		return -EIO;	}	if(write==0)	{		ret = gp_sdcard_read_scatter(sd, sector, sg, ln);	}	else	{		/* ----- Check write protect ----- */		if(sd->sd_func->is_write_protected()==1)			ret = -EROFS;		else			ret = gp_sdcard_write_scatter(sd, sector, sg, ln);	}		gp_board_pin_func_release(pin_handle);	return ret;}

// execute dialog in a child process, leave it running///////////////////////////////////////////////////////////////////////////////////////////pid_t sdialog_call(const char *path, const char *msg, const char *pinName) {        pid_t pid;        dlg_log_printf("sdialog_call/fork/n");        if ((pid = fork()) < 0) {                dlg_log_error("sdialog_call/fork");                return 0L;        }        if (pid == 0) {                char *disp = getenv("DISPLAY");                dlg_log_printf("sdialog_call: in child/n");                if (disp != NULL) {                        DPRINTF("sdialog_call: DISPLAY=%s/n", disp);                } else {                        DPRINTF("DISPLAY not set/n");                }                umask(0);                chdir("/");                DPRINTF("call_dialog: about to exec %s/n", path);                execlp(path, path, pinName, msg, (char *) 0);                DERROR("sdialog_call/execlp");                exit(1);        }        dlg_log_printf("sdialog_call: child PID=%d/n", pid);        return pid;}

bool CSTi7108MainOutput::ShowPlane(stm_plane_id_t planeID){  DEBUGF2(2,("CSTi7108MainOutput::ShowPlane %d/n",(int)planeID));  stm_clk_divider_output_divide_t div;  if(!m_pClkDivider->getDivide(STM_CLK_DISP_HD,&div))  {    DERROR("Cannot get display clock divider/n");    return false;  }  if(planeID == OUTPUT_GDP1)  {    m_pClkDivider->Enable(STM_CLK_GDP1, STM_CLK_SRC_0, div);    DEBUGF2(2,("%s: GDP1 clock set to HD disp clock/n",__PRETTY_FUNCTION__));  }  else if(planeID == OUTPUT_GDP2)  {    m_pClkDivider->Enable(STM_CLK_GDP2, STM_CLK_SRC_0, div);    DEBUGF2(2,("%s: GDP2 clock set to HD disp clock/n",__PRETTY_FUNCTION__));  }  else if (planeID == OUTPUT_VID1)  {    ULONG val = ReadSysCfgReg(SYS_CFG2) | SYS_CFG2_PIP_MODE;    WriteSysCfgReg(SYS_CFG2,val);    m_pClkDivider->Enable(STM_CLK_DISP_PIP, STM_CLK_SRC_0, div);    DEBUGF2(2,("%s: PIP clock set to HD disp clock/n",__PRETTY_FUNCTION__));  }  return CSTmMasterOutput::m_pMixer->EnablePlane(planeID);}

bool Connection::removeLine(LineData* line){    con_list_it t = find(lines.begin(),lines.end(), line);       if(t==lines.end())    {        DERROR("(W) line not found");        return false;    }        LineData* ld = *t;    lines.erase(t);       DASSERT(ld!=NULL);    DASSERT(ld->in!=NULL && ld->out!=NULL);       //tell the soundcomps to remove this input/output pair    ld->in->remInput();    ld->out->remOutput();       //MUST remove link to line in it/og from    ld->in->remLine();    ld->out->remLine();       delete ld;       return true;}

DSocket* d_socket_connect_by_ip(char* ip, int port, DError** error) {    int iResult;    WSADATA wsaData;    // Initialize Winsock    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);    if (iResult != 0) {        printf("WSAStartup failed: %d/n", iResult);        return NULL;    }    DSocket* new_socket = d_malloc(sizeof (DSocket));    struct sockaddr_in sock_adress;    if ((sock_adress.sin_addr.s_addr = inet_addr(ip)) == -1) {        if (error)            *error = DERROR("IP adress %s is invalid", ip);        goto error;    };    sock_adress.sin_family = AF_INET; /* Protocol IP */    sock_adress.sin_port = htons(port);    new_socket->socket_desc = socket(AF_INET, SOCK_STREAM, 0);    if (new_socket->socket_desc == INVALID_SOCKET) {        if (error)            *error = DERROR("Cant create socket, %s", strerror(errno));        goto error;    }    if (connect(new_socket->socket_desc, (const struct sockaddr*) &sock_adress, sizeof (sock_adress)) == SOCKET_ERROR) {        if (error)            *error = DERROR("Connection to %s:%d failed, %s", ip, port, strerror(errno));        goto error;    }    return new_socket;error:    if (new_socket) d_socket_close(new_socket);    return NULL;}

/* * Function irnet_find_lsap_sel (self) * *    Try to lookup LSAP selector in remote LM-IAS * * Basically, we start a IAP query, and then go to sleep. When the query * return, irnet_getvalue_confirm will wake us up, and we can examine the * result of the query... * Note that in some case, the query fail even before we go to sleep, * creating some races... */static intirnet_find_lsap_sel(irnet_socket *	self){  DENTER(IRDA_SR_TRACE, "(self=0x%X)/n", (unsigned int) self);  /* This should not happen */  DABORT(self->iriap, -EBUSY, IRDA_SR_ERROR, "busy with a previous query./n");  /* Create an IAP instance, will be closed in irnet_getvalue_confirm() */  self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,			   irnet_getvalue_confirm);  /* Treat unexpected signals as disconnect */  self->errno = -EHOSTUNREACH;  /* Query remote LM-IAS */  iriap_getvaluebyclass_request(self->iriap, self->saddr, self->daddr,				IRNET_SERVICE_NAME, IRNET_IAS_VALUE);  /* Wait for answer (if not already failed) */  if(self->iriap != NULL)    interruptible_sleep_on(&self->query_wait);  /* Check what happened */  if(self->errno)    {      DEBUG(IRDA_SR_INFO, "IAS query failed! (%d)/n", self->errno);      /* Requested object/attribute doesn't exist */      if((self->errno == IAS_CLASS_UNKNOWN) ||	 (self->errno == IAS_ATTRIB_UNKNOWN))	return (-EADDRNOTAVAIL);      else	return (-EHOSTUNREACH);    }  /* Get the remote TSAP selector */  switch(self->ias_result->type)    {    case IAS_INTEGER:      DEBUG(IRDA_SR_INFO, "result=%d/n", self->ias_result->t.integer);      if(self->ias_result->t.integer != -1)	self->dtsap_sel = self->ias_result->t.integer;      else 	self->dtsap_sel = 0;      break;    default:      self->dtsap_sel = 0;      DERROR(IRDA_SR_ERROR, "bad type ! (0x%X)/n", self->ias_result->type);      break;    }  /* Cleanup */  if(self->ias_result)    irias_delete_value(self->ias_result);  DEXIT(IRDA_SR_TRACE, "/n");  if(self->dtsap_sel)    return 0;  return -EADDRNOTAVAIL;}

inttimeout_wait(int fd, int timeout, int writing){    if (timeout <= 0) {    //    return TRUE; // true        timeout = 0;    }    if (fd < 0) {        DERROR("timeout_wait fd error: %d/n", fd);        return FALSE; //error    }    // second to millisecond     timeout = timeout * 1000;    struct pollfd fds[1];    int ret;    //struct timeval start, end;    fds[0].fd = fd;    while (1) {        //gettimeofday(&start, NULL);        if (writing)            fds[0].events = POLLOUT;        else            fds[0].events = POLLIN;        ret = poll(fds, 1, timeout);        //DINFO("poll:%d/n", ret);        if (ret < 0) {            if (errno == EINTR) {                /*gettimeofday(&end, NULL);                unsigned int td = timediff(&start, &end);                timeout -= td / 1000;                if (timeout <= 0)                    return FALSE;*/                continue;            }            char errbuf[1024];            strerror_r(errno, errbuf, 1024);            DWARNING("timeout_wait poll error: %d, %s/n", fds[0].fd,  errbuf);            return FALSE;        }        break;    }    /*DINFO("poll %x in:%d, out:%d, err:%d, hup:%d/n", fds[0].revents,             fds[0].revents & POLLIN, fds[0].revents & POLLOUT,             fds[0].revents & POLLERR, fds[0].revents & POLLHUP);*/    if ((fds[0].revents & POLLOUT) && writing)        return TRUE;    if ((fds[0].revents & POLLIN) && !writing)        return TRUE;     if ((fds[0].revents & POLLHUP) | (fds[0].revents & POLLERR))        return ERROR;        return ERROR;}

void GOctScale::setState(SoundCompEvent* e){    DASSERT(e!=NULL);    if(e->empty())return;    if(e->getSize()!=sizeof(State))    {        DERROR("size missmatch");        if(e->getSize() < sizeof(State))return;	        DERROR("trying to read...");    }    const State* s = (const State*)e->getData();       ns->setValue(s->noct);       update();}

void GAbs::setState(SoundCompEvent* e){    DASSERT(e!=NULL);    if(e->empty())return;    if(e->getSize()!=sizeof(State))    {        DERROR("size missmatch");        if(e->getSize() < sizeof(State))return;	        DERROR("trying to read...");    }    const State* s = (const State*)e->getData();          b_mode->setValue(s->mode);    sig->setHalf(b_mode->getValue());}

/** * attr必须先初始化为0 */intattr_array2binary(uint8_t *attrformat, uint32_t *attrarray, char attrnum, char *attr){    int i;    int b   = 0; // 已经处理的bit    int idx = 0;    int n;    uint32_t v, flow = 0;    char    mf;    // 前两位分别表示真实删除和标记删除，跳过    // attr[idx] = attr[idx] & 0xfc;    //memset(attr, 0, attrnum);        attr[0] = 0x01;  // 默认设置数据有效，非标记删除    b += 2;    for (i = 0; i < attrnum; i++) {        mf = attrformat[i];        if (mf == 0) {            DERROR("attr format error: %d/n", mf);            return -1;        }        v  = attrarray[i];         //DINFO("idx:%d, b:%d, format:%d, attrvalue:%d, %x/n", idx, b, mf, v, v);        if (v == UINT_MAX) {            v = 0;        }                uint8_t y = (b + mf) % 8;        n = (b + mf) / 8 + (y>0 ? 1: 0);        if (n > 4) {            flow = v >> (32 - b);        }        v = v << b;        uint8_t m = 0xffffffff >> (32 - b);        uint8_t x = attr[idx] & m;        v = v | x;        if (n > 4) {            memcpy(&attr[idx], &v, sizeof(int));        } else {            memcpy(&attr[idx], &v, n);        }        if (y > 0) {            idx += n - 1;        }else{            idx += n;        }        if (n > 4) {            attr[idx] = attr[idx] | flow;        }        b = y;        //DINFO("============================/n");    }