static public long SamplePosition(long sampleIndex,
CaptureMask captureDataMask)
{
long result = sampleOffset +
BytesPerSample(captureDataMask) * sampleIndex;
return(result);
}
static public long SamplePosition(double seconds,
CaptureMask captureDataMask,
ref StatusPacket statusPacket)
{
seconds = Math.Max(0, seconds);
long bytesPerSample = BytesPerSample(captureDataMask);
long freq = 1000 * statusPacket.sampleRate;
long result = (long)(seconds * freq * bytesPerSample);
long err = result % bytesPerSample;
if (err > 0) // must fall on boundary
{
result += (bytesPerSample - err);
}
result += sampleOffset;
return(result);
}
static public long BytesPerSample(CaptureMask captureDataMask)
{
long result = sizeof(ushort); // voltage always present
if ((captureDataMask & CaptureMask.chanMain) != 0)
{
result += sizeof(short);
}
if ((captureDataMask & CaptureMask.chanUsb) != 0)
{
result += sizeof(short);
}
if ((captureDataMask & CaptureMask.chanAux) != 0)
{
result += sizeof(short);
}
return(result);
}
public static long SamplePosition(double seconds,
CaptureMask captureDataMask,
ref StatusPacket statusPacket)
{
seconds = Math.Max(0, seconds);
long bytesPerSample = BytesPerSample(captureDataMask);
long freq = 1000 * statusPacket.sampleRate;
long result = (long)(seconds * freq * bytesPerSample);
long err = result % bytesPerSample;
if (err > 0) // must fall on boundary
result += (bytesPerSample - err);
result += sampleOffset;
return result;
}
public static long SamplePosition(long sampleIndex,
CaptureMask captureDataMask)
{
long result = sampleOffset +
BytesPerSample(captureDataMask) * sampleIndex;
return result;
}
public static long SampleCount(BinaryReader reader,
CaptureMask captureDataMask)
{
return (reader.BaseStream.Length - sampleOffset)
/ BytesPerSample(captureDataMask);
}
public static void GetSample(long sampleIndex,
CaptureMask captureDataMask,
StatusPacket statusPacket,
BinaryReader reader,
ref Sample sample)
{
// remember the index and time
sample.sampleIndex = sampleIndex;
sample.timeStamp = sampleIndex
/ (1000.0 * statusPacket.sampleRate);
// intial settings for all flags
sample.mainPresent =
(captureDataMask & CaptureMask.chanMain) != 0;
sample.usbPresent =
(captureDataMask & CaptureMask.chanUsb) != 0;
sample.auxPresent =
(captureDataMask & CaptureMask.chanAux) != 0;
sample.markerPresent = true;
sample.missing = false;
// abort if no data was selected
long bytesPerSample = BytesPerSample(captureDataMask);
if (bytesPerSample == 0)
return;
// remember original position
long oldPos = reader.BaseStream.Position;
// position the file to the start of the desired sample
long newPos = SamplePosition(sampleIndex, captureDataMask);
if (oldPos != newPos)
reader.BaseStream.Position = newPos;
// get default voltages (V) for the three channels
sample.mainVoltage =
2.0 + statusPacket.outputVoltageSetting * 0.01;
sample.usbVoltage =
(double)statusPacket.initialUsbVoltage * 125 / 1e6f;
if (statusPacket.hardwareRevision < HardwareRev.revB)
sample.usbVoltage /= 2;
sample.auxVoltage =
(double)statusPacket.initialAuxVoltage * 125 / 1e6f;
if (statusPacket.hardwareRevision < HardwareRev.revC)
sample.auxVoltage /= 2;
// Main current (mA)
if (sample.mainPresent)
{
short raw = reader.ReadInt16();
sample.missing = sample.missing ||
raw == missingRawCurrent;
if (!sample.missing)
{
bool coarse = (raw & coarseMask) != 0;
raw &= ~coarseMask;
sample.mainCurrent = raw / 1000f; // uA -> mA
if (coarse)
sample.mainCurrent *= 250;
}
}
// Aux1 current (mA)
if (sample.usbPresent)
{
short raw = reader.ReadInt16();
sample.missing = sample.missing ||
raw == missingRawCurrent;
if (!sample.missing)
{
bool coarse = (raw & coarseMask) != 0;
raw &= ~coarseMask;
sample.usbCurrent = raw / 1000f; // uA -> mA
if (coarse)
sample.usbCurrent *= 250;
}
}
// Aux2 current (mA)
if (sample.auxPresent)
{
short raw = reader.ReadInt16();
sample.missing = sample.missing ||
raw == missingRawCurrent;
if (!sample.missing)
{
bool coarse = (raw & coarseMask) != 0;
raw &= ~coarseMask;
sample.auxCurrent = raw / 1000f; // uA -> mA
if (coarse)
sample.auxCurrent *= 250;
}
}
// Markers and Voltage (V)
{
ushort uraw = reader.ReadUInt16();
sample.missing = sample.missing ||
uraw == missingRawVoltage;
if (!sample.missing)
{
// strip out marker bits
sample.marker0 = (uraw & marker0Mask) != 0;
sample.marker1 = (uraw & marker1Mask) != 0;
uraw &= unchecked((ushort)~markerMask);
// calculate voltage
double voltage = (double)uraw * 125 / 1e6f;
// assign the high-res voltage, as appropriate
if ((statusPacket.leds & Leds.voltageIsAux) != 0)
{
sample.auxVoltage = voltage;
if (statusPacket.hardwareRevision
< HardwareRev.revC)
{
sample.auxVoltage /= 2;
}
}
else
{
sample.mainVoltage = voltage;
if (statusPacket.hardwareRevision
< HardwareRev.revB)
{
sample.mainVoltage /= 2;
}
}
}
}
// restore original position, if we moved it earlier
if (oldPos != newPos)
reader.BaseStream.Position = oldPos;
}
public static long BytesPerSample(CaptureMask captureDataMask)
{
long result = sizeof(ushort); // voltage always present
if ((captureDataMask & CaptureMask.chanMain) != 0)
result += sizeof(short);
if ((captureDataMask & CaptureMask.chanUsb) != 0)
result += sizeof(short);
if ((captureDataMask & CaptureMask.chanAux) != 0)
result += sizeof(short);
return result;
}
static public void GetSample(long sampleIndex,
CaptureMask captureDataMask,
StatusPacket statusPacket,
BinaryReader reader,
ref Sample sample)
{
// remember the index and time
sample.sampleIndex = sampleIndex;
sample.timeStamp = sampleIndex
/ (1000.0 * statusPacket.sampleRate);
// intial settings for all flags
sample.mainPresent =
(captureDataMask & CaptureMask.chanMain) != 0;
sample.usbPresent =
(captureDataMask & CaptureMask.chanUsb) != 0;
sample.auxPresent =
(captureDataMask & CaptureMask.chanAux) != 0;
sample.markerPresent = true;
sample.missing = false;
// abort if no data was selected
long bytesPerSample = BytesPerSample(captureDataMask);
if (bytesPerSample == 0)
{
return;
}
// remember original position
long oldPos = reader.BaseStream.Position;
// position the file to the start of the desired sample
long newPos = SamplePosition(sampleIndex, captureDataMask);
if (oldPos != newPos)
{
reader.BaseStream.Position = newPos;
}
// get default voltages (V) for the three channels
sample.mainVoltage =
2.0 + statusPacket.outputVoltageSetting * 0.01;
sample.usbVoltage =
(double)statusPacket.initialUsbVoltage * 125 / 1e6f;
if (statusPacket.hardwareRevision < HardwareRev.revB)
{
sample.usbVoltage /= 2;
}
sample.auxVoltage =
(double)statusPacket.initialAuxVoltage * 125 / 1e6f;
if (statusPacket.hardwareRevision < HardwareRev.revC)
{
sample.auxVoltage /= 2;
}
// Main current (mA)
if (sample.mainPresent)
{
short raw = reader.ReadInt16();
sample.missing = sample.missing ||
raw == missingRawCurrent;
if (!sample.missing)
{
bool coarse = (raw & coarseMask) != 0;
raw &= ~coarseMask;
sample.mainCurrent = raw / 1000f; // uA -> mA
if (coarse)
{
sample.mainCurrent *= 250;
}
}
}
// Aux1 current (mA)
if (sample.usbPresent)
{
short raw = reader.ReadInt16();
sample.missing = sample.missing ||
raw == missingRawCurrent;
if (!sample.missing)
{
bool coarse = (raw & coarseMask) != 0;
raw &= ~coarseMask;
sample.usbCurrent = raw / 1000f; // uA -> mA
if (coarse)
{
sample.usbCurrent *= 250;
}
}
}
// Aux2 current (mA)
if (sample.auxPresent)
{
short raw = reader.ReadInt16();
sample.missing = sample.missing ||
raw == missingRawCurrent;
if (!sample.missing)
{
bool coarse = (raw & coarseMask) != 0;
raw &= ~coarseMask;
sample.auxCurrent = raw / 1000f; // uA -> mA
if (coarse)
{
sample.auxCurrent *= 250;
}
}
}
// Markers and Voltage (V)
{
ushort uraw = reader.ReadUInt16();
sample.missing = sample.missing ||
uraw == missingRawVoltage;
if (!sample.missing)
{
// strip out marker bits
sample.marker0 = (uraw & marker0Mask) != 0;
sample.marker1 = (uraw & marker1Mask) != 0;
uraw &= unchecked ((ushort)~markerMask);
// calculate voltage
double voltage = (double)uraw * 125 / 1e6f;
// assign the high-res voltage, as appropriate
if ((statusPacket.leds & Leds.voltageIsAux) != 0)
{
sample.auxVoltage = voltage;
if (statusPacket.hardwareRevision
< HardwareRev.revC)
{
sample.auxVoltage /= 2;
}
}
else
{
sample.mainVoltage = voltage;
if (statusPacket.hardwareRevision
< HardwareRev.revB)
{
sample.mainVoltage /= 2;
}
}
}
}
// restore original position, if we moved it earlier
if (oldPos != newPos)
{
reader.BaseStream.Position = oldPos;
}
}
static public long SampleCount(BinaryReader reader,
CaptureMask captureDataMask)
{
return((reader.BaseStream.Length - sampleOffset)
/ BytesPerSample(captureDataMask));
}
