public int setSignals(Signals sigs)
{
if ((sigs != null) &&
(sigs.NrLeads > 0) &&
(sigs.NrLeads <= ISHNEHeader.MAX_NR_LEADS) &&
(sigs.RhythmAVM > 0.0) &&
(sigs.RhythmSamplesPerSecond > 0))
{
_Header.ECGNrLeads = sigs.NrLeads;
_Header.ECGSampleRate = (Int16)sigs.RhythmSamplesPerSecond;
for (int i = 0; i < sigs.NrLeads; i++)
{
_Header.SetLeadType(i, sigs[i].Type);
_Header.ECGLeadQuality[i] = 0;
_Header.ECGLeadResolution[i] = (Int16)(sigs.RhythmAVM * ISHNEHeader.UV_TO_AMPLITUDE);
}
if (sigs.IsBuffered)
{
BufferedSignals bs = sigs.AsBufferedSignals;
_Header.ECGNrSamples = (bs.RealRhythmEnd - bs.RealRhythmStart) * _Header.ECGNrLeads;
}
else
{
int rhythmStart, rhythmEnd;
sigs.CalculateStartAndEnd(out rhythmStart, out rhythmEnd);
_Header.ECGNrSamples = (rhythmEnd - rhythmStart) * _Header.ECGNrLeads;
}
_Signals = sigs;
return(0);
}
return(1);
}
public override int Write(Stream output)
{
try
{
if ((output != null) &&
output.CanWrite)
{
if (Works())
{
_Header.VarBlockOffset = _Header.Size() + BYTES_BEFORE_HEADER;
_Header.VarBlockSize = (_HeaderAndVarBlock != null) && (_HeaderAndVarBlock.Length < _Header.VarBlockOffset) ? _HeaderAndVarBlock.Length - _Header.VarBlockOffset : 0;
_Header.ECGOffset = _Header.VarBlockOffset + _Header.VarBlockSize;
if ((_HeaderAndVarBlock == null) ||
(_HeaderAndVarBlock.Length < _Header.ECGOffset))
{
_HeaderAndVarBlock = new byte[_Header.ECGOffset];
}
// Begin: code that handles overriding of AVM
double avmOverride = _AVMOverride;
int nrLeads = _Signals.NrLeads;
double[] avm = new double[nrLeads];
if (avmOverride <= 0.0)
{
for (int i = 0; i < nrLeads; i++)
{
avm[i] = _Header.GetLeadAmplitude(i);
}
}
else
{
for (int i = 0; i < nrLeads; i++)
{
_Header.ECGLeadResolution[i] = (Int16)(avmOverride * ISHNEHeader.UV_TO_AMPLITUDE);
avm[i] = avmOverride;
}
}
// End: code that handles overriding of AVM
BytesTool.writeString(MAGIC_NUMBER, _HeaderAndVarBlock, 0, MAGIC_NUMBER.Length);
if (_Header.Write(_HeaderAndVarBlock, BYTES_BEFORE_HEADER, _Header.Size()) != 0)
{
return(0x4);
}
CRCTool tool = new CRCTool();
tool.Init(CRCTool.CRCCode.CRC_CCITT);
ushort crc = tool.CalcCRCITT(_HeaderAndVarBlock, BYTES_BEFORE_HEADER, _HeaderAndVarBlock.Length - BYTES_BEFORE_HEADER);
BytesTool.writeBytes(crc, _HeaderAndVarBlock, MAGIC_NUMBER.Length, SHORT_SIZE, true);
output.Write(_HeaderAndVarBlock, 0, _Header.ECGOffset);
if (_Signals.IsBuffered)
{
BufferedSignals bs = _Signals.AsBufferedSignals;
int rhythmCur = bs.RealRhythmStart,
rhythmEnd = bs.RealRhythmEnd,
stepSize = 60 * bs.RhythmSamplesPerSecond;
byte[] data = null;
for (; rhythmCur < rhythmEnd; rhythmCur += stepSize)
{
if (!bs.LoadSignal(rhythmCur, rhythmCur + stepSize))
{
return(0x8);
}
int buff_size = _WriteSignal(ref data, _Signals, avm);
if (buff_size < 0)
{
return(0x10);
}
output.Write(data, 0, buff_size);
}
}
else
{
int rhythmStart, rhythmEnd;
_Signals.CalculateStartAndEnd(out rhythmStart, out rhythmEnd);
byte[] data = null;
int buff_size = _WriteSignal(ref data, _Signals, avm);
if (buff_size < 0)
{
return(0x10);
}
output.Write(data, 0, buff_size);
}
return(0x0);
}
return(0x2);
}
}
catch
{
return(0x10);
}
return(0x1);
}
public override int Read(Stream input, int offset)
{
_Signals = null;
if ((input != null) &&
input.CanRead &&
input.CanSeek &&
(offset >= 0))
{
_InputStreamOffset = input.Position + offset;
_HeaderAndVarBlock = new byte[_Header.Size() + BYTES_BEFORE_HEADER];
input.Position += offset;
if (BytesTool.readStream(input, _HeaderAndVarBlock, 0, _HeaderAndVarBlock.Length) == _HeaderAndVarBlock.Length)
{
string magicNumber = BytesTool.readString(_HeaderAndVarBlock, 0, MAGIC_NUMBER.Length);
if (string.Compare(magicNumber, MAGIC_NUMBER) == 0)
{
if ((_Header.Read(_HeaderAndVarBlock, BYTES_BEFORE_HEADER, _HeaderAndVarBlock.Length - BYTES_BEFORE_HEADER) == 0) &&
_Header.Works())
{
if (_Header.VarBlockSize > 0)
{
byte[] buff = new byte[_HeaderAndVarBlock.Length + _Header.VarBlockSize];
BytesTool.copy(buff, 0, _HeaderAndVarBlock, 0, _HeaderAndVarBlock.Length);
if (BytesTool.readStream(input, buff, _HeaderAndVarBlock.Length, _Header.VarBlockSize) != _Header.VarBlockSize)
{
return(0x10);
}
_HeaderAndVarBlock = buff;
}
CRCTool tool = new CRCTool();
tool.Init(CRCTool.CRCCode.CRC_CCITT);
ushort crc = (ushort)BytesTool.readBytes(_HeaderAndVarBlock, MAGIC_NUMBER.Length, SHORT_SIZE, true);
if (!_CRCValidation ||
(crc == tool.CalcCRCITT(_HeaderAndVarBlock, BYTES_BEFORE_HEADER, _HeaderAndVarBlock.Length - BYTES_BEFORE_HEADER)))
{
if (input.CanSeek)
{
long nrSamples = (input.Length - _Header.ECGOffset) / 2;
if ((nrSamples > _Header.ECGNrSamples) &&
(nrSamples <= int.MaxValue))
{
_Header.ECGNrSamples = (int)nrSamples;
}
}
BufferedSignals sigs = new BufferedSignals(this, (byte)_Header.ECGNrLeads);
// Begin: code that handles overriding of AVM
double avm = _AVMOverride;
if (avm <= 0.0)
{
avm = double.MaxValue;
for (int i = 0; i < _Header.ECGNrLeads; i++)
{
sigs[i] = new Signal();
sigs[i].Type = _Header.GetLeadType(i);
double val = _Header.GetLeadAmplitude(i);
if (val < avm)
{
avm = val;
}
}
}
else
{
for (int i = 0; i < _Header.ECGNrLeads; i++)
{
sigs[i] = new Signal();
sigs[i].Type = _Header.GetLeadType(i);
}
}
// End: code that handles overriding of AVM
sigs.RhythmAVM = avm;
sigs.RhythmSamplesPerSecond = _Header.ECGSampleRate;
sigs.RealRhythmSamplesPerSecond = _Header.ECGSampleRate;
sigs.RealRhythmStart = 0;
sigs.RealRhythmEnd = _Header.ECGNrSamples / _Header.ECGNrLeads;
_InputStream = input;
_Signals = sigs;
sigs.Init();
return(0x0);
}
return(0x20);
}
return(0x8);
}
return(0x4);
}
return(0x2);
}
return(0x1);
}
