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

/**/brief 通过本地socket连接到服务 * /param[in] name 服务名称 * /param[out] fd 返回socket * /return *   - AM_SUCCESS 成功 *   - 其他值 错误代码 */AM_ErrorCode_t AM_LocalConnect(const char *name, int *fd){	struct sockaddr_un addr;	int s, ret;#if 0		assert(name && fd);		s = socket(AF_LOCAL, SOCK_STREAM, 0);	if(s==-1)	{		AM_DEBUG(1, "cannot create local socket /"%s/"", strerror(errno));		return AM_FAILURE;	}		addr.sun_family = AF_LOCAL;        strncpy(addr.sun_path, name, sizeof(addr.sun_path)-1);                ret = connect(s, (struct sockaddr*)&addr, SUN_LEN(&addr));        if(ret==-1)        {        	AM_DEBUG(1, "connect to /"%s/" failed /"%s/"", name, strerror(errno));        	close(s);		return AM_FAILURE;        }                *fd = s;#endif        return AM_SUCCESS;}

/**/brief 将像素映射为颜色 * /param[in] fmt 图形模式  * /param[in] pix 像素值 * /param[out] col 返回映射的颜色值  * /return *   - AM_SUCCESS 成功 *   - 其他值 错误代码(见am_osd.h) */AM_ErrorCode_t AM_OSD_MapPixel(AM_OSD_PixelFormat_t *fmt, uint32_t pix, AM_OSD_Color_t *col){	assert(fmt && col);		if(AM_OSD_PIXEL_FORMAT_TYPE_IS_PALETTE(fmt->type))	{		if(pix>=fmt->palette.color_count)		{			AM_DEBUG(1, "illegal pixel, must in (0~%d)", fmt->palette.color_count-1);			return AM_OSD_ERR_ILLEGAL_PIXEL;		}				*col = fmt->palette.colors[pix];	}	else if(AM_OSD_PIXEL_FORMAT_TYPE_IS_YUV(fmt->type))	{		AM_DEBUG(1, "cannot map YUV pixel to color");		return AM_OSD_ERR_NOT_SUPPORTED;	}	else	{		AM_RGB_PIXEL_TO_COLOR(fmt, pix, col);	}		return AM_SUCCESS;}

/**/brief 通过本地socket发送命令 * /param fd socket * /param[in] cmd 命令字符串 * /return *   - AM_SUCCESS 成功 *   - 其他值 错误代码 */AM_ErrorCode_t AM_LocalSendCmd(int fd, const char *cmd){	AM_ErrorCode_t ret;	int len;		assert(cmd);		len = strlen(cmd)+1;		ret = try_write(fd, (const char*)&len, sizeof(int));	if(ret!=AM_SUCCESS)	{		AM_DEBUG(1, "write local socket failed");		return ret;	}		ret = try_write(fd, cmd, len);	if(ret!=AM_SUCCESS)	{		AM_DEBUG(1, "write local socket failed");		return ret;	}		AM_DEBUG(2, "write cmd: %s", cmd);		return AM_SUCCESS;}

/**************************************************************************** * Functions ***************************************************************************/static AM_ErrorCode_t dvb_open (AM_FEND_Device_t *dev, const AM_FEND_OpenPara_t *para){	char name[PATH_MAX];	int fd;	#if 1	snprintf(name, sizeof(name), "/dev/dvb0.frontend%d", dev->dev_no);		fd = open(name, O_RDWR);	if(fd==-1)	{		AM_DEBUG(1, "cannot open %s, error:%s", name, strerror(errno));		return AM_FEND_ERR_CANNOT_OPEN;	}		if(ioctl(fd, FE_GET_INFO, &dev->info))	{		close(fd);		AM_DEBUG(1, "cannot get frontend's infomation, error:%s", strerror(errno));		return AM_FEND_ERR_IO;	}		dev->drv_data = (void*)fd;#endif	return AM_SUCCESS;}

/**/brief 通过本地socket接收响应字符串 * /param fd socket * /param[out] buf 缓冲区 * /param len 缓冲区大小 * /return *   - AM_SUCCESS 成功 *   - 其他值 错误代码 */AM_ErrorCode_t AM_LocalGetResp(int fd, char *buf, int len){	AM_ErrorCode_t ret;	int bytes;		assert(buf);		ret = try_read(fd, (char*)&bytes, sizeof(int));	if(ret!=AM_SUCCESS)	{		AM_DEBUG(1, "read local socket failed");		return ret;	}		if(len<bytes)	{		AM_DEBUG(1, "respond buffer is too small");		return AM_FAILURE;	}		ret = try_read(fd, buf, bytes);	if(ret!=AM_SUCCESS)	{		AM_DEBUG(1, "read local socket failed");		return ret;	}		return AM_SUCCESS;}

static AM_ErrorCode_t dvb_sec_begin_cb (void *user_data, const char *sec){	AM_DVBConfig_t *conf=(AM_DVBConfig_t*)user_data;		if(conf->in_service_sec)	{		AM_DEBUG(1, "unknown section");		return AM_CFG_ERR_SYNTAX;	}		if(!strcmp(sec, "service"))	{		if(conf->service_count<MAX_SERVICE_COUNT)		{			conf->service_count++;		}		else		{			AM_DEBUG(1, "too many services");		}		conf->in_service_sec = 1;		return AM_SUCCESS;	}	return AM_CFG_ERR_UNKNOWN_TAG;}

static int vol_update (DTV_Window_t *win, AM_OSD_Surface_t *s){	AM_ErrorCode_t ret = AM_SUCCESS;	AM_OSD_Rect_t sr, dr;	int i =0 ,tmp;	ret = AM_AOUT_GetVolume(DTV_AOUT_DEV_NO, &(vol.cur_vol_value));	if(ret!=AM_SUCCESS)	{		printf("AM_AOUT_SetVolume fail!/n");	}	else	{			AM_DEBUG(1, "vol_value = %d",vol.cur_vol_value);	}	//draw vol bar		sr.x = 0;	sr.y = 0;	sr.w = gfx.volume_img->width;	sr.h = gfx.volume_img->height;		dr.x = 300;	dr.y = 450;	dr.w = gfx.volume_img->width;	dr.h = gfx.volume_img->height;		AM_OSD_Blit(gfx.volume_img, &sr, s, &dr, NULL);	if(tmp = vol.cur_vol_value / VOL_VALUE_STEP)		AM_DEBUG(1, "%d/n",tmp);		for(i=0;i<tmp;i++)	{		sr.x = 0;		sr.w = 0;		sr.w = gfx.volume_value_img->width;		sr.h = gfx.volume_value_img->height;				dr.x = 376 + ( i * (gfx.volume_value_img->width + 4));		dr.y = 459;		dr.w = gfx.volume_value_img->width;		dr.h = gfx.volume_value_img->height;				AM_OSD_Blit(gfx.volume_value_img, &sr, s, &dr, NULL);		}	AM_TIME_GetClock(&now);		return 0;}

static void dump_bytes(int dev_no, int fid, const uint8_t *data, int len, void *user_data){	FILE *fp;	int did = data[8];	int sec = data[6];		#if 0	if(did!=3)		return;		if(sections[sec].got)	{		if((sections[sec].len!=len) || memcmp(sections[sec].data, data, len))		{			AM_DEBUG(1, "SECTION %d MISMATCH LEN: %d", sec, len);		}	}	else	{		sections[sec].len = len;		sections[sec].got = 1;		memcpy(sections[sec].data, data, len);		AM_DEBUG(1, "GET SECTION %d LEN: %d", sec, len);	}#endif#if 0	int did = data[8];	int bid = (data[9]<<24)|(data[10]<<16)|(data[11]<<8)|data[12];	int sec = data[6];		if(did!=3)		return;	if(sec_mask[sec])		return;		sec_mask[sec] = 1;	AM_DEBUG(1, "get section %d", sec);		fseek(fp, bid*4030, SEEK_SET);	fwrite(data+13, 1, len-17, fp);#endif#if 1	int i;		printf("section:/n");	for(i=0;i<len;i++)	{		printf("%02x ", data[i]);		if(((i+1)%16)==0) printf("/n");	}		if((i%16)!=0) printf("/n");#endif}

static void si_section_callback(int dev_no, int fid, const uint8_t *data, int len, void *user_data){	int hsi;	int t;	AM_SI_SectionHeader_t header;	void *p_table;		AM_DEBUG(1, "GET A SECTION LEN: %d", len);	t = get_sec_by_hfilter(fid);	if (t == -1)	{		AM_DEBUG(1, "Unknown filter id 0x%x", fid);		return;	}	/*Copy the data*/	memcpy(si_sections[t].data, data, len);		AM_SI_Create(&hsi);	AM_SI_GetSectionHeader(hsi, (uint8_t*)si_sections[t].data, (uint16_t)len, &header);	/*Print the header*/	AM_DEBUG(1, "SectionHeader::/n/ttable_id/t/t0x%x/n/tsyntax_indicator/t0x%x/n/tprv_indicator/t/t0x%x/n/tlength/t/t/t0x%x/n/textension/t/t0x%x/n/tverion/t/t/t0x%x/n/tcur_next/t/t0x%x/n/tsec_num/t/t/t0x%x/n/tlast_sec_num/t/t0x%x",	header.table_id,header.syntax_indicator,header.private_indicator,	header.length, header.extension, header.version, 	header.cur_next_indicator, header.sec_num, header.last_sec_num);	/*Decode*/	if (AM_SI_DecodeSection(hsi, si_sections[t].pid, 							(uint8_t*)si_sections[t].data, 							(uint16_t)len, &p_table) == AM_SUCCESS)	{		AM_DEBUG(1, "Section Successfully decoded");		/*Print detail*/		if (si_sections[t].print)			si_sections[t].print(p_table);		AM_SI_ReleaseSection(hsi, p_table->i_table_id, (void*)p_table);	}	else	{		AM_DEBUG(1, "Section  decoded failed");	}			AM_SI_Destroy(hsi);	si_sections[t].last_sec = header.last_sec_num;		/*Start next section receive*/	si_test_table_start_next_section(t);}

/**/brief 将字符串值转化为整数 * /param[in] value 字符串值 * /param[out] pv 输出整数的指针 * /return *   - AM_SUCCESS 成功 *   - 其他值 错误代码(见am_cfg.h) */AM_ErrorCode_t AM_CFG_Value2Int(const char *value, int *pv){	int rc;		assert(value && pv);		if(value[0]=='0')	{		if((value[1]=='x')||(value[1]=='X'))		{			rc = sscanf(value+2, "%x", pv);		}		else		{			rc = sscanf(value, "%o", pv);		}	}	else	{		rc = sscanf(value, "%d", pv);	}		if(rc!=1)	{		AM_DEBUG(1, "key is not an integer");		return AM_CFG_ERR_BAD_FOTMAT;	}		return AM_SUCCESS;}

/**/brief 注册一个事件回调函数 * /param dev_no 回调函数对应的设备ID * /param event_type 回调函数对应的事件类型 * /param cb 回调函数指针 * /param data 传递给回调函数的用户定义参数 * /return *   - AM_SUCCESS 成功 *   - 其他值 错误代码 */AM_ErrorCode_t AM_EVT_Subscribe(int dev_no, int event_type, AM_EVT_Callback_t cb, void *data){	AM_Event_t *evt;	int pos;		assert(cb);		/*分配事件*/	evt = malloc(sizeof(AM_Event_t));	if(!evt)	{		AM_DEBUG(1, "not enough memory");		return AM_EVT_ERR_NO_MEM;	}		evt->dev_no = dev_no;	evt->type   = event_type;	evt->cb     = cb;	evt->data   = data;		pos = event_type%AM_EVT_BUCKET_COUNT;		/*加入事件哈希表中*/	pthread_mutex_lock(&lock);		evt->next   = events[pos];	events[pos] = evt;		pthread_mutex_unlock(&lock);		return AM_SUCCESS;}

/**/brief 创建一个单元格控件*/static AM_ErrorCode_t table_cell_create(AM_GUI_Table_t *tab, AM_GUI_Widget_t **cell, int row, int col, int hspan, int vspan){	AM_GUI_TableCell_t *c;	AM_ErrorCode_t ret;		c = (AM_GUI_TableCell_t*)malloc(sizeof(AM_GUI_TableCell_t));	if(!cell)	{		AM_DEBUG(1, "not enough memory");		return AM_GUI_ERR_NO_MEM;	}		ret = AM_GUI_WidgetInit(AM_GUI_WIDGET(tab)->gui, AM_GUI_WIDGET(c));	if(ret!=AM_SUCCESS)	{		free(c);		return ret;	}		AM_GUI_WIDGET(c)->type = AM_GUI_WIDGET_TABLE_CELL;		c->row   = row;	c->col   = col;	c->hspan = hspan;	c->vspan = vspan;		*cell = AM_GUI_WIDGET(c);	return AM_SUCCESS;}

static AM_ErrorCode_t dvb_set_source(AM_DMX_Device_t *dev, AM_DMX_Source_t src){	char buf[32];	char *cmd;		snprintf(buf, sizeof(buf), "/sys/class/stb/demux%d_source", dev->dev_no);		switch(src)	{		case AM_DMX_SRC_TS0:			cmd = "ts0";		break;		case AM_DMX_SRC_TS1:			cmd = "ts1";		break;		case AM_DMX_SRC_TS2:			cmd = "ts2";		break;		case AM_DMX_SRC_HIU:			cmd = "hiu";		break;		default:			AM_DEBUG(1, "do not support demux source %d", src);		return AM_DMX_ERR_NOT_SUPPORTED;	}		return AM_FileEcho(buf, cmd);}

AM_ErrorCode_t aml_write (AM_SMC_Device_t *dev, const uint8_t *data, int *len, int timeout){	struct pollfd pfd;	int fd = (int)dev->drv_data;	int ret;		pfd.fd = fd;	pfd.events = POLLOUT;		ret = poll(&pfd, 1, timeout);	if(ret!=1)	{		return AM_SMC_ERR_TIMEOUT;	}		ret = write(fd, data, *len);	if(ret<0)	{		AM_DEBUG(1, "card write error %s", strerror(errno));		return AM_SMC_ERR_IO;	}		*len = ret;	return AM_SUCCESS;}

/**/brief Performs a blind scan operation.*/static AM_ErrorCode_t  AM_FEND_IBlindScanAPI_Start(int dev_no){		AM_FEND_Device_t *dev = NULL;	AM_ErrorCode_t ret = AM_SUCCESS;	fend_get_openned_dev(dev_no, &dev);		if(!dev->drv->blindscan_scan)	{		AM_DEBUG(1, "fronend %d no not support blindscan_scan", dev_no);		return AM_FEND_ERR_NOT_SUPPORTED;	}		pthread_mutex_lock(&dev->lock);			struct dvbsx_blindscanpara * pbsPara = &(dev->bs_setting.bsPara);	/*driver need to set in blindscan mode*/	ret = dev->drv->blindscan_scan(dev, pbsPara);	if(ret != AM_SUCCESS)	{		ret = AM_FEND_ERR_BLINDSCAN;		pthread_mutex_unlock(&dev->lock);		return ret;		}		pthread_mutex_unlock(&dev->lock);		return ret;}

static AM_ErrorCode_t dvb_read(AM_DMX_Device_t *dev, AM_DMX_Filter_t *filter, uint8_t *buf, int *size){	int fd = (int)filter->drv_data;	int len = *size;	int ret;	struct pollfd pfd;		if(fd==-1)		return AM_DMX_ERR_NOT_ALLOCATED;		pfd.events = POLLIN|POLLERR;	pfd.fd     = fd;		ret = poll(&pfd, 1, 0);	if(ret<=0)		return AM_DMX_ERR_NO_DATA;		ret = read(fd, buf, len);	if(ret<=0)	{		if(errno==ETIMEDOUT)			return AM_DMX_ERR_TIMEOUT;		AM_DEBUG(1, "read demux failed (%s) %d", strerror(errno), errno);		return AM_DMX_ERR_SYS;	}		*size = ret;	return AM_SUCCESS;}

AM_ErrorCode_t AM_CFG_Input(const char *path,	AM_CFG_SecBeginCb_t sec_begin_cb,	AM_CFG_KeyCb_t key_cb,	AM_CFG_SecEndCb_t sec_end_cb,	void *user_data){	AM_CFG_Parser_t parser;	FILE *fp;	AM_ErrorCode_t ret;		assert(path);		if (!(fp = fopen(path, "r")))	{		AM_DEBUG(1, "%s", strerror(errno));		return AM_CFG_ERR_CANNOT_OPEN_FILE;	}		memset(&parser, 0, sizeof(AM_CFG_Parser_t));		parser.path = path;	parser.line = 1;	parser.fp = fp;	parser.sec_begin_cb = sec_begin_cb;	parser.sec_end_cb = sec_end_cb;	parser.key_cb = key_cb;	parser.user_data = user_data;		ret = cfg_parse(&parser);		if(parser.sec_stack)	{		AM_DEBUG(1, "/'}/' mismatch");		cfg_error(&parser);	}		while(parser.sec_stack)	{		cfg_pop_sec(&parser);	}		if(parser.buffer)		AM_MEM_Free(parser.buffer);		fclose(fp);	return ret;}

/**/brief 根据设备号取得设备结构指针*/static AM_INLINE AM_ErrorCode_t fend_get_dev(int dev_no, AM_FEND_Device_t **dev){	if((dev_no<0) || (dev_no>=FEND_DEV_COUNT))	{		AM_DEBUG(1, "invalid frontend device number %d, must in(%d~%d)", dev_no, 0, FEND_DEV_COUNT-1);		return AM_FEND_ERR_INVALID_DEV_NO;	}		*dev = &fend_devices[dev_no];	return AM_SUCCESS;}

/**/brief 根据设备号取得设备结构指针*/static AM_INLINE AM_ErrorCode_t dmx_get_dev(int dev_no, AM_DMX_Device_t **dev){    if((dev_no<0) || (dev_no>=DMX_DEV_COUNT))    {        AM_DEBUG(1, "invalid demux device number %d, must in(%d~%d)", dev_no, 0, DMX_DEV_COUNT-1);        return AM_DMX_ERR_INVALID_DEV_NO;    }    *dev = &dmx_devices[dev_no];    return AM_SUCCESS;}

/**/brief 根据设备号取得设备结构*/static AM_INLINE AM_ErrorCode_t vout_get_dev(int dev_no, AM_VOUT_Device_t **dev){	if((dev_no<0) || (dev_no>=VOUT_DEV_COUNT))	{		AM_DEBUG(1, "invalid vout device number %d, must in(%d~%d)", dev_no, 0, VOUT_DEV_COUNT-1);		return AM_VOUT_ERR_INVALID_DEV_NO;	}		*dev = &vout_devices[dev_no];	return AM_SUCCESS;}

/**/brief 设定调色板，此操作只对调色板模式的表面有效 * /param[in] s 绘图表面 * /param[in] pal 设定颜色数组 * /param start 要设定的调色板起始项 * /param count 要设定的颜色数目 * /return *   - AM_SUCCESS 成功 *   - 其他值 错误代码(见am_osd.h) */AM_ErrorCode_t AM_OSD_SetPalette(AM_OSD_Surface_t *surf, AM_OSD_Color_t *pal, int start, int count){	AM_OSD_PixelFormat_t *fmt;	int first, last;	AM_ErrorCode_t ret = AM_SUCCESS;		assert(surf && pal);		fmt = surf->format;	if(!AM_OSD_PIXEL_FORMAT_TYPE_IS_PALETTE(fmt->type))	{		AM_DEBUG(1, "not a palette pixel format");		return AM_OSD_ERR_NOT_SUPPORTED;	}		first = AM_MAX(0, start);	last  = AM_MIN(fmt->palette.color_count, start+count);		start = first;	count = last-first;		if(count)	{		memcpy(fmt->palette.colors+start, pal, count*sizeof(AM_OSD_Color_t));				if(surf->flags&AM_OSD_SURFACE_FL_OSD)		{			AM_OSD_Device_t *dev = (AM_OSD_Device_t*)surf->drv_data;						if(!dev->drv->set_palette)			{				AM_DEBUG(1, "do not support set_palette");				return AM_OSD_ERR_NOT_SUPPORTED;			}						ret = dev->drv->set_palette(dev, pal, start, count);		}	}		return ret;}

static AM_ErrorCode_t dvb_set_para (AM_FEND_Device_t *dev, const struct dvb_frontend_parameters *para){	int fd = (int)dev->drv_data;		if(ioctl(fd, FE_SET_FRONTEND, para)==-1)	{		AM_DEBUG(1, "ioctl FE_SET_FRONTEND failed, error:%s", strerror(errno));		return AM_FAILURE;	}	return AM_SUCCESS;}

/**/brief 根据设备号取得设备结构并检查设备是否已经打开*/static AM_INLINE AM_ErrorCode_t fend_get_openned_dev(int dev_no, AM_FEND_Device_t **dev){	AM_TRY(fend_get_dev(dev_no, dev));		if(!(*dev)->openned)	{		AM_DEBUG(1, "frontend device %d has not been openned", dev_no);		return AM_FEND_ERR_INVALID_DEV_NO;	}		return AM_SUCCESS;}

/**/brief 根据设备号取得设备结构并检查设备是否已经打开*/static AM_INLINE AM_ErrorCode_t vout_get_openned_dev(int dev_no, AM_VOUT_Device_t **dev){	AM_TRY(vout_get_dev(dev_no, dev));		if(!(*dev)->openned)	{		AM_DEBUG(1, "vout device %d has not been openned", dev_no);		return AM_VOUT_ERR_INVALID_DEV_NO;	}		return AM_SUCCESS;}

AM_ErrorCode_t aml_deactive (AM_SMC_Device_t *dev){	int fd = (int)dev->drv_data;		if(ioctl(fd, AMSMC_IOC_DEACTIVE, 0))	{		AM_DEBUG(1, "deactive card failed /"%s/"", strerror(errno));		return AM_SMC_ERR_IO;	}		return AM_SUCCESS;}

/**/brief 将字符串值转化为IPV6地址 * /param[in] value 字符串值 * /param[out] addr 输出IPV6地址的指针 * /return *   - AM_SUCCESS 成功 *   - 其他值 错误代码(见am_cfg.h) */AM_ErrorCode_t AM_CFG_Value2IPV6(const char *value, struct in6_addr *addr){	assert(value && addr);		if(inet_pton(AF_INET6, value, addr)<=0)	{		AM_DEBUG(1, "key is not an IPV6 address");		return AM_CFG_ERR_BAD_FOTMAT;	}		return AM_SUCCESS;}

/**/brief 根据设备号取得设备结构并检查设备是否已经打开*/static AM_INLINE AM_ErrorCode_t dmx_get_openned_dev(int dev_no, AM_DMX_Device_t **dev){    AM_TRY(dmx_get_dev(dev_no, dev));    if((*dev)->open_count <= 0)    {        AM_DEBUG(1, "demux device %d has not been openned", dev_no);        return AM_DMX_ERR_INVALID_DEV_NO;    }    return AM_SUCCESS;}

static AM_ErrorCode_t dvb_get_status (AM_FEND_Device_t *dev, fe_status_t *status){	int fd = (int)dev->drv_data;		if(ioctl(fd, FE_READ_STATUS, status)==-1)	{		AM_DEBUG(1, "ioctl FE_READ_STATUS failed, error:%s", strerror(errno));		return AM_FAILURE;	}	return AM_SUCCESS;}

/**/brief 根据ID取得对应filter结构，并检查设备是否在使用*/static AM_INLINE AM_ErrorCode_t dmx_get_used_filter(AM_DMX_Device_t *dev, int filter_id, AM_DMX_Filter_t **pf){    AM_DMX_Filter_t *filter;    if((filter_id<0) || (filter_id>=DMX_FILTER_COUNT))    {        AM_DEBUG(1, "invalid filter id, must in %d~%d", 0, DMX_FILTER_COUNT-1);        return AM_DMX_ERR_INVALID_ID;    }    filter = &dev->filters[filter_id];    if(!filter->used)    {        AM_DEBUG(1, "filter %d has not been allocated", filter_id);        return AM_DMX_ERR_NOT_ALLOCATED;    }    *pf = filter;    return AM_SUCCESS;}

AM_ErrorCode_t aml_set_param (AM_SMC_Device_t *dev, const AM_SMC_Param_t *para){	int fd = (int)dev->drv_data;		if(ioctl(fd, AMSMC_IOC_SET_PARAM, para))	{		AM_DEBUG(1, "set card params failed /"%s/"", strerror(errno));		return AM_SMC_ERR_IO;	}		return AM_SUCCESS;}