alarmfile.cpp

采集卡demo

#include "stdafx.h"
#include <afxwin.h>
#include "alarmfile.h"
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <io.h>
#include <stdio.h>
#include <errno.h>

AlarmFile::AlarmFile()
{

	frameBuf = NULL;
	size = FRAME_BUF_SIZE;
	count = 0;
	writePtr = 0;
	readPtr = 0;
	framesCounter = 0;
	framesToWriteImmediatly = 0;
	canStopWrite = TRUE;

}

AlarmFile::~AlarmFile()
{
	if(frameBuf)
		free(frameBuf);
}

int AlarmFile::Reset()
{

	if(!frameBuf)
		frameBuf = (UCHAR *)malloc(FRAME_BUF_SIZE);
	if(frameBuf == NULL){
		AfxMessageBox("error:no enough memory\n");
		bInitOk = FALSE;
	}

	size = FRAME_BUF_SIZE;
	count = 0;
	writePtr = 0;
	readPtr = 0;
	framesCounter = 0;
	framesToWriteImmediatly = 0;
	canStopWrite = TRUE;
	return 0;
}


int AlarmFile::Setup(ULONG framesBeforeAlarm, ULONG framesAfterAlarm)
{

	// convert time to frames based counter
	framesBeforeCurPos = framesBeforeAlarm;
	framesToStopWrite = framesAfterAlarm;

	return 0;
}

int AlarmFile::MakeRoom(int length)
{
	ASSERT(length < size);
	ASSERT(size == FRAME_BUF_SIZE);

	TRACE("makeroom\n");

	while(length > size - count){
		// delete the frames on the header

		// get the frames on the first
		FRAME_INFO_HEADER curFrameInfo;
		GetData((UCHAR *)&curFrameInfo, sizeof(FRAME_INFO_HEADER));

		// delete the frame
		ASSERT(curFrameInfo.magic == FRAME_INFO_HEADER_MAGIC);
		RemoveData(curFrameInfo.frameLen - sizeof(FRAME_INFO_HEADER));
		
		framesCounter -= TypeToFrames(curFrameInfo.frameType);
	//	ASSERT((count >= 0) && (readPtr < FRAME_BUF_SIZE) && (framesCounter >= 0));

	}

	return size - count;

}

int AlarmFile::StoreData(UCHAR *dataBuf, int length)
{
	// store the data
	int firstPart;

	ASSERT(length <= size -count);

	if((firstPart = size - writePtr) < length){
		// writeptr will wrap the buf
		 memcpy((UCHAR *)(frameBuf + writePtr), dataBuf, firstPart);
		 memcpy(frameBuf, (UCHAR *)(dataBuf + firstPart), length - firstPart);
	}else{
		memcpy((UCHAR *)(frameBuf + writePtr), dataBuf, length);
	}

	writePtr += length;
	if(writePtr > size)
		writePtr -= size;
	count += length;

	
	return length;
}


int AlarmFile::GetData(UCHAR *dataBuf, int dataLen)
{
	ASSERT(dataBuf );

	ASSERT(dataLen <= count);

	int firstPart;
	if((firstPart = size - readPtr) < dataLen){
		memcpy(dataBuf, (UCHAR *)(frameBuf + readPtr), firstPart);
		memcpy((UCHAR *)(dataBuf + firstPart), frameBuf, dataLen - firstPart);
	}else{
		memcpy(dataBuf, (UCHAR *)(frameBuf + readPtr), dataLen);
	}
	readPtr += dataLen;
	if(readPtr > size)
		readPtr -= size;
	count -= dataLen;
	ASSERT(count >= 0);

	return dataLen;
}


int AlarmFile::TypeToFrames(FrameType_t frameType)
{
	switch(frameType){
	case PktIFrames:
	case PktPFrames:
		return 1;
	case PktBBPFrames:
		return 3;
	default:
		return 1;
	}
}





int AlarmFile::FramePush(int fileHandle, UCHAR *frameData, ULONG length, FrameType_t frameType, BOOL breakable)
{
	FRAME_INFO_HEADER frameInfoH;

	if(framesToWriteImmediatly || !canStopWrite){
		if(breakable && (framesToWriteImmediatly <= 0)){
			TRACE("stop \n");
			canStopWrite = TRUE;
			framesToWriteImmediatly = 0;
			return 0;
		}

		TRACE("continus to write\n");
		_write(fileHandle, frameData, length);
		
		framesToWriteImmediatly -= TypeToFrames(frameType);

		return 0;
	}

	length += sizeof(FRAME_INFO_HEADER);

	MakeRoom(length);

	frameInfoH.frameLen = length;
	frameInfoH.frameType = frameType;
	frameInfoH.magic = FRAME_INFO_HEADER_MAGIC;
	frameInfoH.breakable = breakable;

	TRACE("queue the frames\n");
	StoreData((UCHAR *)&frameInfoH, sizeof(FRAME_INFO_HEADER));
	StoreData(frameData, length - sizeof(FRAME_INFO_HEADER));

	framesCounter += TypeToFrames(frameType);
	
	return 0;
}




int AlarmFile::Trigger(int fileHandle)
{
	if(framesCounter == 0)
		return 0;

	TRACE("trigger:framesCounter = %d\n", framesCounter);

	// search the  frame that can be in the header
	BOOL startWrite = FALSE;

	while(framesCounter){
		FRAME_INFO_HEADER frameInfoH;
		GetData((UCHAR *)&frameInfoH, sizeof(FRAME_INFO_HEADER));
		
		ASSERT(frameInfoH.magic == FRAME_INFO_HEADER_MAGIC);

		// if in the range of frames that should be written and it's breakable
		if((/*(framesCounter <= framesBeforeCurPos + 5) || ( framesCounter >= framesBeforeCurPos -5) || */
			(framesCounter < framesBeforeCurPos)) && frameInfoH.breakable){
			TRACE("start write\n");
			WriteData(fileHandle, frameInfoH.frameLen - sizeof(FRAME_INFO_HEADER));
			startWrite = TRUE;
		}else if(startWrite){
			TRACE("write\n");
			WriteData(fileHandle, frameInfoH.frameLen - sizeof(FRAME_INFO_HEADER));
		}else {
			TRACE("remove:framesCounter = %d\n", framesCounter);
			RemoveData(frameInfoH.frameLen - sizeof(FRAME_INFO_HEADER));
		}

		framesCounter -= TypeToFrames(frameInfoH.frameType);
		ASSERT(framesCounter >= 0);
	}

//	if(startWrite){
//		framesToWriteImmediatly = framesToStopWrite;
//		canStopWrite = FALSE;
//	}


	return 0;

}

int AlarmFile::RemoveData(int length)
{
	ASSERT(length <= FRAME_BUF_SIZE);
	readPtr += length;
	if(readPtr > FRAME_BUF_SIZE)
		readPtr -= FRAME_BUF_SIZE;

	count -= length;

	
	return 0;
}

int AlarmFile::WriteData(int fileHandle, int length)
{

	int firstPart;

	if((firstPart = size - readPtr) < length){
		_write(fileHandle, (UCHAR *)(frameBuf + readPtr), firstPart);
		_write(fileHandle, frameBuf, length - firstPart);
	}else{
		_write(fileHandle, (UCHAR *)(frameBuf + readPtr), length);
	}
	readPtr += length;
	if(readPtr > size)
		readPtr -= size;
	count -= length;
	ASSERT(count >= 0);
	
	return 0;
}