Ejemplo n.º 1
0
static void main_loop(int flag, LogLevel_t level, const char *logName)
{
	int cnt = 0;
	DBG("Log Test Start: %d.", cnt++);
	INFO("Info: %d", cnt++);
	ERR("Err: %d", cnt++);
	FILE *fp = fopen("not_exit", "b");
	ERRSTR("Open none exist file");

	LogHandle hLog;

	hLog = log_create(level, flag, logName, 1024 * 1024);
	assert(hLog != NULL);
	
	for(level = LOG_LEVEL_DBG; level < LOG_LEVEL_MAX; level++)
	{
		log_print(hLog, "Log level: %d", level);
		log_set_level(hLog, level);
		
		log_debug(hLog, "Debug info, log name %s", logName);
		log_warning(hLog,"Warning, flag: %u, level: %d", flag, level);
		log_error(hLog,"Error, log handle addr: 0x%X", hLog);
	}

	const char *pErr = str_err((int)E_BUSY);
	printf("Err string: %s\n", pErr);

	log_print(hLog, "Log test success!");
}
Ejemplo n.º 2
0
/*****************************************************************************
 Prototype    : msg_process
 Description  : process msg
 Input        : VidEncThrEnv *envp  
                CommonMsg *msgBuf   
 Output       : None
 Return Value : static
 Calls        : 
 Called By    : 
 
  History        :
  1.Date         : 2012/3/8
    Author       : Sun
    Modification : Created function

*****************************************************************************/
static Int32 msg_process(VidEncThrEnv *envp, CommonMsg *msgBuf)
{
	Int32 ret;

	/* recv msg */
	ret = msg_recv(envp->hMsg, msgBuf, sizeof(CommonMsg));
	if(ret < 0) {
		ERR("img enc thr recv msg err: %s", str_err(ret));
		return ret;
	}

	/* process msg */
	MsgHeader *msgHdr = &msgBuf->header;
	switch(msgHdr->cmd) {
	case APPCMD_NEW_DATA:
		ret = vid_enc_thr_run(envp, (ImgMsg *)msgBuf);
		break;
	case APPCMD_SET_VID_ENC_PARAMS:
		ret = vid_enc_params_update(envp);
		break;
	case APPCMD_EXIT:
		envp->exit = TRUE;
		break;
	default:
		ERR("unkown cmd: 0x%X", (unsigned int)msgHdr->cmd);
		ret = E_UNSUPT;
		break;
	}

	return ret;
}
Ejemplo n.º 3
0
    void print_robot_chart(robot_chart &chart)
    {
        typedef robot_chart::error_map_t error_map_t;

        LOG_TRACE("robot succ num = %d\r\n", chart.n_succ);
        LOG_TRACE("robot fail num = %d\r\n", chart.n_fail);

        char   buf[128];

        for(error_map_t::iterator itr = chart.error_map.begin(); itr != chart.error_map.end(); itr++)
        {
            int err_type = itr->first;
            int err_occur_num = itr->second;

            str_err(err_type, buf, sizeof(buf));
            

            LOG_TRACE("num of error<%d, %s> is %d\r\n", err_type, buf, err_occur_num);
        }
    }
Ejemplo n.º 4
0
/*****************************************************************************
 Prototype    : msg_process
 Description  : process msg
 Input        : EncoderHandle hEnc  
                CommonMsg *msgBuf   
 Output       : None
 Return Value : static
 Calls        : 
 Called By    : 
 
  History        :
  1.Date         : 2012/3/8
    Author       : Sun
    Modification : Created function

*****************************************************************************/
static Int32 msg_process(EncoderHandle hEnc, CommonMsg *msgBuf)
{
	Int32 ret;

	/* recv msg */
	ret = msg_recv(hEnc->hMsg, (MsgHeader *)msgBuf, sizeof(CommonMsg), 0);
	if(ret < 0) {
		ERR("%s recv msg err: %s", hEnc->name, str_err(ret));
		return ret;
	}

	/* process msg */
	MsgHeader *msgHdr = &msgBuf->header;
	switch(msgHdr->cmd) {
	case APPCMD_NEW_DATA:
		ret = encode_frame(hEnc, (ImgMsg *)msgBuf);
		break;
	case APPCMD_SET_ENC_PARAMS:
		ret = enc_params_update(hEnc, msgBuf->buf, msgHdr->dataLen);
		break;
	case APPCMD_SET_UPLOAD_PARAMS:
		if( msgHdr->dataLen == sizeof(UploadParams))
			ret = upload_update(hEnc, (UploadParams *)msgBuf->buf);
		else
			ERR("invalid len of upload params");
		break;
	case APPCMD_UPLOAD_CTRL:
		ret = upload_control(hEnc->hUpload, msgHdr->param[0], msgBuf->buf);
		break;
	case APPCMD_EXIT:
		hEnc->exit = TRUE;
		break;
	default:
		ERR("unkown cmd: 0x%X", (unsigned int)msgHdr->cmd);
		ret = E_UNSUPT;
		break;
	}

	return ret;
}
/*****************************************************************************
 Prototype    : detector_uart_open
 Description  : open uart device 
 Input        : DetectorHandle hDetector  
 Output       : None
 Return Value : static
 Calls        : 
 Called By    : 
 
  History        :
  1.Date         : 2012/4/6
    Author       : Sun
    Modification : Created function

*****************************************************************************/
static Int32 detector_uart_open(DetectorHandle hDetector)
{

	Int32						i, status = E_UNSUPT;
	DetectorUart				*dev;
	const CamDetectorParam	    *params = DETECTOR_GET_PARAMS(hDetector);

	dev = calloc(1, sizeof(DetectorUart));
	if(!dev) {
		ERR("memory allocation of dev failed.");
		return  E_NOMEM;
	}

	/* set private data as our dev info */
	DETECTOR_SET_PRIVATE(hDetector, dev);
	memset(dev->lastFrameCode, FRAME_TRIG_BASE, sizeof(dev->lastFrameCode));

	/* probe and init detector */
	i = 0;
	while(uartDetectorFxns[i] != NULL) {
		if(uartDetectorFxns[i]->init) {
			status = uartDetectorFxns[i]->init(dev, params->detecotorId);
			if(!status) {
				dev->opts = uartDetectorFxns[i];
				break;
			}
		}
		i++;
	}
	
	if(status) {
		ERR("init detector <%d> failed, %s", params->detecotorId, str_err(status));
		goto free_buf;
	}

	if(!dev->opts || !dev->opts->singleTrigParse) {
		ERR("opts should not be NULL");
		status = E_IO;
		goto free_buf;
	}

	/* start detector */
	dev->timeout = 1;	//set to default value: 100ms
	status = detector_uart_start(dev);
	if(status) {
		ERR("start failed");
		goto free_buf;
	}

	/* check packet len */
	if(dev->packetLen < 1 || dev->packetLen > RX_BUF_SIZE) {
		ERR("packet len invalid");
		status = E_NOSPC;
		goto free_buf;
	}

	/* pre parse params */
	if(dev->opts->capPreParse)
		dev->opts->capPreParse(dev, params);

	/* set dev fd */
	hDetector->fd = dev->fd;
	
	return E_NO;

free_buf:
	if(dev->fd > 0)
		close(dev->fd);
	
	if(dev)
		free(dev);

	DETECTOR_SET_PRIVATE(hDetector, NULL);
	return status;
}
Ejemplo n.º 6
0
/*****************************************************************************
 Prototype    : vid_enc_thr_run
 Description  : add osd and do jpeg encode
 Input        : VidEncThrEnv *envp  
                ImgMsg *msg         
 Output       : None
 Return Value : static
 Calls        : 
 Called By    : 
 
  History        :
  1.Date         : 2012/3/9
    Author       : Sun
    Modification : Created function

*****************************************************************************/
static Int32 vid_enc_thr_run(VidEncThrEnv *envp, ImgMsg *msg)
{
	Int32 	err;
	
	/* Add osd first & ignore error */
	err = add_osd(envp->hOsd, msg, &envp->osdCfg.vidOsd);

	/* Init buffer and args for encode   */
	AlgBuf			inBuf, outBuf;
	BufHandle		hBufIn, hBufOut;
	H264EncInArgs	inArgs;
	H264EncOutArgs	outArgs;
	Int32			dispFlags = 0;
	
	hBufIn = msg->hBuf;
	inBuf.buf = buffer_get_user_addr(msg->hBuf);
	inBuf.bufSize = buffer_get_size(msg->hBuf);
	assert(inBuf.buf && inBuf.bufSize);

	dispFlags = FD_FLAG_NOT_FREE_BUF;
	hBufOut = envp->hBufEnc;
	
	outBuf.buf = buffer_get_user_addr(hBufOut);
	outBuf.bufSize = buffer_get_size(hBufOut);
	
	inArgs.size = sizeof(inArgs);
	inArgs.inputID = msg->index;
	inArgs.timeStamp = 0;
	
	outArgs.size = sizeof(outArgs);
	outArgs.bytesGenerated = 0;

	/* do h264 encode */
	err = h264_enc_process(envp->hH264Enc, &inBuf, &inArgs, &outBuf, &outArgs);
	if(err) {
		ERR("h264 enc err: %s", str_err(err));
		goto err_quit;
	}

	/* free input buffer */
	static int cnt = 0;
	DBG("<%d>h264 free raw buf",++cnt);
	buf_pool_free(hBufIn);
	hBufIn = NULL;

	/* modify frame info */
	msg->dimension.colorSpace = FMT_H264;
	msg->dimension.size = outArgs.bytesGenerated;
	msg->frameType = outArgs.frameType;
	msg->hBuf = hBufOut;
	buffer_set_bytes_used(hBufOut, outArgs.bytesGenerated);

	//DBG("<%d> h264 enc run ok", msg->index);

	/* dispatch h.264 data */
	err = frame_disp_run(envp->hDispatch, envp->hMsg, msg, NULL, dispFlags);
	if(err) {
		ERR("dispatch h264 data failed");
		goto err_quit;
	}

	return E_NO;

err_quit:
	if(hBufIn)
		buf_pool_free(hBufIn);
	
	return err;
}
Ejemplo n.º 7
0
int Message(
    DWORD Flags,
    size_t Buttons,
    const wchar_t *Title,
    const wchar_t * const *Items,
    size_t ItemsNumber,
    Plugin* PluginNumber,
    const GUID* Id
)
{
	string strTempStr;
	string strClipText;
	int X1,Y1,X2,Y2;
	int Length, BtnLength;
	DWORD I, MaxLength, StrCount;
	BOOL ErrorSets=FALSE;
	const wchar_t **Str;
	wchar_t *PtrStr;
	const wchar_t *CPtrStr;
	string strErrStr;

	IsWarningStyle = (Flags&MSG_WARNING) != 0;
	IsErrorType = (Flags&MSG_ERRORTYPE) != 0;

	if(IsErrorType)
	{
		LastError = GetLastError();
		NtStatus = ifn.RtlGetLastNtStatus();
		ErrorSets = GetErrorString(strErrStr);
	}

#if 1 // try to replace inserts
	if (Items && 0 != (Flags & MSG_INSERT_STRINGS))
	{
		string str_err(strErrStr);
		DWORD insert_mask = 0;
		size_t len = strErrStr.GetLength(), pos = 0, inserts_n = 0, inserts[10];

		for (size_t i = 1; i <= ItemsNumber-Buttons; ++i)
		{
			if (0 != (Flags & MSG_INSERT_STR(i)))
			{
				inserts[inserts_n++] = i;
				if (inserts_n >= ARRAYSIZE(inserts))
					break;
			}
		}

		while (str_err.Pos(pos, L"%", pos))
		{
			if (pos >= len-1)
				break;

			if (str_err.At(pos+1) >= L'1' && str_err.At(pos+1) <= L'9')
			{
				size_t insert_i = 0, pos1 = pos+1;
				while (pos1 < len && str_err.At(pos1) >= L'0' && str_err.At(pos1) <= L'9')
				{
					insert_i = 10*insert_i + str_err.At(pos1) - L'0';
					++pos1;
				}
				if (insert_i >= 1 && insert_i <= inserts_n)
				{
					insert_mask |= MSG_INSERT_STR(inserts[insert_i-1]);
					const wchar_t *replacement = Items[inserts[insert_i-1]-1];
					str_err.Replace(pos,pos1-pos,replacement);
					len += wcslen(replacement) - (pos1-pos);
					pos += wcslen(replacement) - (pos1-pos);
				}
				else
					pos = pos1;
			}
			else if (str_err.At(pos+1) == L'%') // "%%"
				pos += 2;
			else
				++pos;
		}
		if (insert_mask == (Flags & MSG_INSERT_STRINGS))
			strErrStr = str_err;
	}
#endif

	// выделим пам¤ть под рабочий массив указателей на строки (+запас 16)
	Str=(const wchar_t **)xf_malloc((ItemsNumber+ADDSPACEFORPSTRFORMESSAGE) * sizeof(wchar_t*));

	if (!Str)
		return -1;

	StrCount=static_cast<DWORD>(ItemsNumber-Buttons);

	// предварительный обсчет максимального размера.
	for (BtnLength=0,I=0; I<static_cast<DWORD>(Buttons); I++) //??
	{
		BtnLength+=HiStrlen(Items[I+StrCount])+2+2+1; // "[ ", " ]", " "
	}
	if(BtnLength)
	{
		BtnLength--;
	}

	DWORD MAX_WIDTH_MESSAGE = Max(ScrX-1-5-5, BtnLength);

	for (MaxLength=BtnLength,I=0; I<StrCount; I++)
	{
		if (static_cast<DWORD>(Length=StrLength(Items[I]))>MaxLength)
			MaxLength=Length;
	}

	// учтем размер заголовка
	if (Title && *Title)
	{
		I=(DWORD)StrLength(Title)+2;

		if (MaxLength < I)
			MaxLength=I;

		strClipText.Append(Title).Append(L"\r\n\r\n");
	}

	// перва¤ коррекци¤ максимального размера
	MaxLength = Min(MaxLength, MAX_WIDTH_MESSAGE);

	// теперь обработаем MSG_ERRORTYPE
	DWORD CountErrorLine=0;

	if ((Flags & MSG_ERRORTYPE) && ErrorSets)
	{
		strClipText.Append(strErrStr).Append(L"\r\n");

		// подсчет количества строк во врапенном сообщениеи
		++CountErrorLine;
		//InsertQuote(ErrStr); // оквочим
		// вычисление "красивого" размера
		DWORD LenErrStr=(DWORD)strErrStr.GetLength();

		if (LenErrStr > MAX_WIDTH_MESSAGE)
		{
			// половина меньше?
			if (LenErrStr/2 < MAX_WIDTH_MESSAGE)
			{
				// а половина + 1/3?
				if ((LenErrStr+LenErrStr/3)/2 < MAX_WIDTH_MESSAGE)
					LenErrStr=(LenErrStr+LenErrStr/3)/2;
				else
					LenErrStr/=2;
			}
			else
				LenErrStr=MAX_WIDTH_MESSAGE;
		}

		MaxLength = Max(MaxLength, LenErrStr);

		// а теперь проврапим
		FarFormatText(strErrStr,LenErrStr,strErrStr,L"\n",0); //?? MaxLength ??
		PtrStr = strErrStr.GetBuffer();

		//BUGBUG: string не предназначен дл¤ хранени¤ строк разделЄнных \0
		while ((PtrStr=wcschr(PtrStr,L'\n')) )
		{
			*PtrStr++=0;

			if (*PtrStr)
				CountErrorLine++;
		}

		strErrStr.ReleaseBuffer();

		if (CountErrorLine > ADDSPACEFORPSTRFORMESSAGE)
			CountErrorLine=ADDSPACEFORPSTRFORMESSAGE; //??
	}

	//BUGBUG: string не предназначен дл¤ хранени¤ строк разделЄнных \0
	// заполн¤ем массив...
	CPtrStr=strErrStr;

	for (I=0; I < CountErrorLine; I++)
	{
		Str[I]=CPtrStr;
		CPtrStr+=StrLength(CPtrStr)+1;

		if (!*CPtrStr) // два идущих подр¤д нул¤ - "хандец" всему
		{
			++I;
			break;
		}
	}

	bool EmptyText=false;
	if(ItemsNumber==Buttons && !I)
	{
		EmptyText=true;
		Str[I]=L"";
		I++;
		StrCount++;
		ItemsNumber++;
	}

	for (size_t J=0; J < ItemsNumber-(EmptyText?1:0); ++J, ++I)
	{
		Str[I]=Items[J];
	}

	for (size_t i = 0; i < ItemsNumber-Buttons; ++i)
	{
		strClipText.Append(Items[i]).Append(L"\r\n");
	}
	strClipText.Append(L"\r\n");
	for (size_t i = ItemsNumber-Buttons; i < ItemsNumber; ++i)
	{
		if(i > ItemsNumber-Buttons)
		{
			strClipText.Append(L' ');
		}
		strClipText.Append(Items[i]);
	}

	StrCount+=CountErrorLine;
	MessageX1=X1=(int(ScrX-MaxLength))/2-4;
	MessageX2=X2=X1+MaxLength+9;
	Y1=(ScrY-static_cast<int>(StrCount))/2-2;

	if (Y1 < 0)
		Y1=0;

	MessageY1=Y1;
	MessageY2=Y2=Y1+StrCount+3;
	string strHelpTopic(strMsgHelpTopic);
	strMsgHelpTopic.Clear();
	// *** ¬ариант с ƒиалогом ***

	if (Buttons>0)
	{
		size_t ItemCount=StrCount+Buttons+1;
		DialogItemEx *PtrMsgDlg;
		DialogItemEx *MsgDlg = new DialogItemEx[ItemCount+1];

		if (!MsgDlg)
		{
			xf_free(Str);
			return -1;
		}

		for (DWORD i=0; i<ItemCount+1; i++)
			MsgDlg[i].Clear();

		int RetCode;
		MessageY2=++Y2;
		MsgDlg[0].Type=DI_DOUBLEBOX;
		MsgDlg[0].X1=3;
		MsgDlg[0].Y1=1;
		MsgDlg[0].X2=X2-X1-3;
		MsgDlg[0].Y2=Y2-Y1-1;

		if (Title && *Title)
			MsgDlg[0].strData = Title;

		FARDIALOGITEMTYPES TypeItem=DI_TEXT;
		unsigned __int64 FlagsItem=DIF_SHOWAMPERSAND;
		BOOL IsButton=FALSE;
		int CurItem=0;
		bool StrSeparator=false;
		bool Separator=false;
		for (PtrMsgDlg=MsgDlg+1,I=1; I < ItemCount; ++I, ++PtrMsgDlg, ++CurItem)
		{
			if (I==StrCount+1 && !StrSeparator && !Separator)
			{
				PtrMsgDlg->Type=DI_TEXT;
				PtrMsgDlg->Flags=DIF_SEPARATOR;
				PtrMsgDlg->Y1=PtrMsgDlg->Y2=I+1;
				CurItem--;
				I--;
				Separator=true;
				continue;
			}
			if(I==StrCount+1)
			{
				TypeItem=DI_BUTTON;
				FlagsItem=DIF_CENTERGROUP|DIF_DEFAULTBUTTON|DIF_FOCUS;
				IsButton=TRUE;
				FirstButtonIndex=CurItem+1;
				LastButtonIndex=CurItem;
			}
			else
			{
				FlagsItem&=~DIF_DEFAULTBUTTON;
			}

			PtrMsgDlg->Type=TypeItem;
			PtrMsgDlg->Flags|=FlagsItem;
			CPtrStr=Str[CurItem];

			if (IsButton)
			{
				PtrMsgDlg->Y1=Y2-Y1-2+(Separator?1:0);
				PtrMsgDlg->strData+=CPtrStr;
				LastButtonIndex++;
			}
			else
			{
				PtrMsgDlg->X1=(Flags & MSG_LEFTALIGN)?5:-1;
				PtrMsgDlg->Y1=I+1;
				wchar_t Chr=*CPtrStr;

				if (Chr == L'\1' || Chr == L'\2')
				{
					CPtrStr++;
					PtrMsgDlg->Flags|=(Chr==2?DIF_SEPARATOR2:DIF_SEPARATOR);
					if(I==StrCount)
					{
						StrSeparator=true;
					}
				}
				else
				{
					if (StrLength(CPtrStr)>X2-X1-9)
					{
						PtrMsgDlg->Type=DI_EDIT;
						PtrMsgDlg->Flags|=DIF_READONLY|DIF_BTNNOCLOSE|DIF_SELECTONENTRY;
						PtrMsgDlg->X1=5;
						PtrMsgDlg->X2=X2-X1-5;
						PtrMsgDlg->strData=CPtrStr;
					}
					else
					{
						//xstrncpy(PtrMsgDlg->Data,CPtrStr,Min((int)MAX_WIDTH_MESSAGE,(int)sizeof(PtrMsgDlg->Data))); //?? ScrX-15 ??
						PtrMsgDlg->strData = CPtrStr; //BUGBUG, wrong len
					}
				}
			}
		}

		{
			if(Separator)
			{
				FirstButtonIndex++;
				LastButtonIndex++;
				MessageY2++;
				Y2++;
				MsgDlg[0].Y2++;
				ItemCount++;
			}
			Dialog Dlg(MsgDlg,ItemCount,MsgDlgProc, &strClipText);
			if (X1 == -1) X1 = 0;
			if (Y1 == -1) Y1 = 0;
			Dlg.SetPosition(X1,Y1,X2,Y2);
			if(Id) Dlg.SetId(*Id);

			if (!strHelpTopic.IsEmpty())
				Dlg.SetHelp(strHelpTopic);

			Dlg.SetPluginOwner(reinterpret_cast<Plugin*>(PluginNumber)); // «апомним номер плагина

			if (IsWarningStyle)
			{
				Dlg.SetDialogMode(DMODE_WARNINGSTYLE);
			}

			Dlg.SetDialogMode(DMODE_MSGINTERNAL);
			if (Flags & MSG_NOPLUGINS)
				Dlg.SetDialogMode(DMODE_NOPLUGINS);
			FlushInputBuffer();

			if (Flags & MSG_KILLSAVESCREEN)
				SendDlgMessage((HANDLE)&Dlg,DM_KILLSAVESCREEN,0,0);

			Dlg.Process();
			RetCode=Dlg.GetExitCode();
		}

		delete [] MsgDlg;
		xf_free(Str);
		return(RetCode<0?RetCode:RetCode-StrCount-1-(Separator?1:0));
	}

	// *** Ѕез ƒиалога! ***
	SetCursorType(0,0);

	if (!(Flags & MSG_KEEPBACKGROUND))
	{
		SetScreen(X1,Y1,X2,Y2,L' ',ColorIndexToColor((Flags & MSG_WARNING)?COL_WARNDIALOGTEXT:COL_DIALOGTEXT));
		MakeShadow(X1+2,Y2+1,X2+2,Y2+1);
		MakeShadow(X2+1,Y1+1,X2+2,Y2+1);
		Box(X1+3,Y1+1,X2-3,Y2-1,ColorIndexToColor((Flags & MSG_WARNING)?COL_WARNDIALOGBOX:COL_DIALOGBOX),DOUBLE_BOX);
	}

	SetColor((Flags & MSG_WARNING)?COL_WARNDIALOGTEXT:COL_DIALOGTEXT);

	if (Title && *Title)
	{
		string strTempTitle = Title;

		if (strTempTitle.GetLength() > MaxLength)
			strTempTitle.SetLength(MaxLength);

		GotoXY(X1+(X2-X1-1-(int)strTempTitle.GetLength())/2,Y1+1);
		FS<<L" "<<strTempTitle<<L" ";
	}

	for (I=0; I<StrCount; I++)
	{
		CPtrStr=Str[I];
		wchar_t Chr=*CPtrStr;

		if (Chr == 1 || Chr == 2)
		{
			Length=X2-X1-5;

			if (Length>1)
			{
				SetColor((Flags & MSG_WARNING)?COL_WARNDIALOGBOX:COL_DIALOGBOX);
				GotoXY(X1+3,Y1+I+2);
				DrawLine(Length,(Chr == 2?3:1));
				CPtrStr++;
				int TextLength=StrLength(CPtrStr);

				if (TextLength<Length)
				{
					GotoXY(X1+3+(Length-TextLength)/2,Y1+I+2);
					Text(CPtrStr);
				}

				SetColor((Flags & MSG_WARNING)?COL_WARNDIALOGBOX:COL_DIALOGTEXT);
			}

			continue;
		}

		if ((Length=StrLength(CPtrStr))>ScrX-15)
			Length=ScrX-15;

		int Width=X2-X1+1;
		wchar_t *lpwszTemp = nullptr;
		int PosX;
		if (Flags & MSG_LEFTALIGN)
		{
			lpwszTemp = (wchar_t*)xf_malloc((Width-10+1)*sizeof(wchar_t));
			_snwprintf(lpwszTemp,Width-10+1,L"%.*s",Width-10,CPtrStr);
			GotoXY(X1+5,Y1+I+2);
		}
		else
		{
			PosX=X1+(Width-Length)/2;
			lpwszTemp = (wchar_t*)xf_malloc((PosX-X1-4+Length+X2-PosX-Length-3+1)*sizeof(wchar_t));
			_snwprintf(lpwszTemp,PosX-X1-4+Length+X2-PosX-Length-3+1,L"%*s%.*s%*s",PosX-X1-4,L"",Length,CPtrStr,X2-PosX-Length-3,L"");
			GotoXY(X1+4,Y1+I+2);
		}

		Text(lpwszTemp);
		xf_free(lpwszTemp);
	}

	/* $ 13.01.2003 IS
	   - ѕринудительно уберем запрет отрисовки экрана, если количество кнопок
	     в сообщении равно нулю и макрос закончил выполн¤тьс¤. Ёто необходимо,
	     чтобы заработал прогресс-бар от плагина, который был запущен при помощи
	     макроса запретом отрисовки (bugz#533).
	*/
	xf_free(Str);

	if (!Buttons)
	{
		if (ScrBuf.GetLockCount()>0 && !CtrlObject->Macro.PeekKey())
			ScrBuf.SetLockCount(0);

		ScrBuf.Flush();
	}

	return 0;
}
Ejemplo n.º 8
0
/*****************************************************************************
 Prototype    : img_enc_thr_run
 Description  : add osd and do jpeg encode
 Input        : EncoderHandle hEnc  
                ImgMsg *msg         
 Output       : None
 Return Value : static
 Calls        : 
 Called By    : 
 
  History        :
  1.Date         : 2012/3/9
    Author       : Sun
    Modification : Created function

*****************************************************************************/
static Int32 encode_frame(EncoderHandle hEnc, ImgMsg *msg)
{
	Int32 	err;

	/* Add osd first & ignore error */
	err = add_osd(hEnc->hOsd, msg, &hEnc->osdInfo);

	/* Init buffer for encode   */
	AlgBuf		inBuf, outBuf;
	BufHandle	hBufIn, hBufOut;
	Bool		saveToLocal = FALSE;
	
	hBufIn = msg->hBuf;
	inBuf.buf = buffer_get_user_addr(hBufIn);
	inBuf.bufSize = buffer_get_bytes_used(hBufIn);
	hEnc->hPoolIn = buffer_get_pool(hBufIn);
	
	if(hEnc->hPoolEnc) {
		/* Alloc buffer for encoded data */
		hBufOut = buf_pool_alloc_wait(hEnc->hPoolEnc, BUF_ALLOC_TIMEOUT);
		//hBufOut = buf_pool_alloc(hEnc->hPoolEnc);
		if(!hBufOut) {
			/* alloc buffer failed, use buf for save */
			//DBG("<%s> save file to local file system", hEnc->name);
			hBufOut = hEnc->hBufEnc;
			saveToLocal = TRUE;
		}
	} else {
		/* no pool */
		hBufOut = hEnc->hBufEnc;
	}
	
	outBuf.buf = buffer_get_user_addr(hBufOut);
	outBuf.bufSize = buffer_get_size(hBufOut);
	if(!outBuf.buf || !outBuf.bufSize) {
		ERR("<%s> got invalid encode buf handle", hEnc->name);
		err = E_NOMEM;
		goto err_quit;
	}

	/* do encode process */
	//pthread_mutex_lock(hEnc->mutex);
	err = hEnc->ops->encProcess(hEnc->hEncode, &inBuf, &outBuf, msg);
	//pthread_mutex_unlock(hEnc->mutex);
	if(err) {
		ERR("<%s> enc err: %s", hEnc->name, str_err(err));
		goto err_quit;
	}

	/* free input buffer */
	buf_pool_free(hBufIn);
	hBufIn = NULL;

	/* modify msg for send */
	msg->hBuf = hBufOut;

	if(!saveToLocal) {
		/* upload to server */
		err = upload_run(hEnc->hUpload, hEnc->hMsg, msg);
	}
	
	/* save to local filesys */
	if(saveToLocal || err) {
		if(hEnc->ops->saveFrame)
			err = hEnc->ops->saveFrame(msg, hEnc->saveRootPath);
		goto err_quit;
	}

	//DBG("<%d> %s encode ok", msg->index, hEnc->name);

	return E_NO;

err_quit:

	/* free buffers */
	if(hBufIn)
		buf_pool_free(hBufIn);
	
	if(!saveToLocal && hEnc->hPoolEnc)
		buf_pool_free(hBufOut);

	return err;
}