public ID3v2(System.IO.Stream stream)
{
using (FrameReader reader = new FrameReader(stream))
{
setvalues(reader);
}
}
internal OutputPrepared(byte protocolVersion, FrameReader reader)
{
var length = reader.ReadInt16();
QueryId = new byte[length];
reader.Read(QueryId, 0, length);
Metadata = new RowSetMetadata(reader, protocolVersion >= 4);
}
private void setvalues(FrameReader reader)
{
this.frameCount = reader.FrameCount;
this.header = reader.TagHeader;
this.title = reader.Read<string>("TIT2", ReadString, null);
this.artist = reader.Read<string>("TPE1", ReadString, null);
this.album = reader.Read<string>("TALB", ReadString, null);
this.year = reader.Read<string>("TYER", ReadString, null);
this.trackstring = reader.Read<string>("TRCK", ReadString, null);
if (trackstring == null)
{
this.tracknumber = -1;
}
else if (trackstring.Contains("/"))
{
string s = trackstring.Substring(0, trackstring.IndexOf('/'));
this.tracknumber = -1;
int.TryParse(s, out this.tracknumber);
}
else
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < trackstring.Length; i++)
{
if (char.IsDigit(trackstring[i]))
sb.Append(trackstring[i]);
}
this.tracknumber = -1;
int.TryParse(sb.ToString(), out this.tracknumber);
}
}
public static Task <DS4CalibrationRecord> CalibrateAsync(FrameReader reader)
{
#if DSAPI
return(Task <DS4CalibrationRecord> .Run(() => Calibrator.Calibrate(reader.DSAPI)));
#else
return(Task <DS4CalibrationRecord> .Run(() => Calibrator.Calibrate(reader.Device)));
#endif
}
internal OutputPrepared(byte protocolVersion, FrameReader reader)
{
var length = reader.ReadInt16();
QueryId = new byte[length];
reader.Read(QueryId, 0, length);
Metadata = new RowSetMetadata(reader, protocolVersion >= 4);
}
public void can_parse_header(string input, string key, string value)
{
var parser = new FrameReader(new MemoryStream());
var result = parser.ParseHeader(input);
Assert.AreEqual(key, result.Key, "key");
Assert.AreEqual(value, result.Value, "value");
}
public ID3v2(string filename)
{
using (System.IO.FileStream fs = new System.IO.FileStream(filename, System.IO.FileMode.Open))
using (FrameReader reader = new FrameReader(fs))
{
setvalues(reader);
}
}
protected override void Load(FrameReader reader)
{
_exception = new FunctionFailureException(Message)
{
Keyspace = reader.ReadString(),
Name = reader.ReadString(),
ArgumentTypes = reader.ReadStringList()
};
}
/// <summary>
/// Get ready for the first shot.
/// </summary>
public void AttachToReader(FrameReader reader)
{
if (_reader != null)
{
throw new InvalidOperationException("We've already attached to a reader!");
}
_reader = reader;
}
public TagHeader(FrameReader reader)
{
byte[] buffer = new byte[9];
bool found = false;
int offset = 0;
this.version = new Version(0, 0);
while (reader.stream.Position < reader.stream.Length && !found && reader.stream.Position < 200)
{
int b = reader.stream.ReadByte();
if (b == 0x49)
{
reader.stream.Read(buffer, offset, 9);
string text = Encoding.ASCII.GetString(buffer);
if (buffer[0] == 0x44 &&
buffer[1] == 0x33 &&
buffer[2] < 0xff &&
buffer[3] < 0xff &&
//buffer[4] is the flag byte
buffer[5] < 0x80 &&
buffer[6] < 0x80 &&
buffer[7] < 0x80 &&
buffer[8] < 0x80)
{
this.version = new Version(buffer[2], buffer[3]);
this.flags = (TagFlags)buffer[4];
this.size = BinaryConverter.ToInt32(buffer, 5, true);
if (this.size + reader.stream.Position > reader.stream.Length)
{
this.version = new Version(0, 0);
break;
}
if ((flags & TagFlags.ExtendedHeader) == TagFlags.ExtendedHeader)
{
reader.stream.Read(buffer, 0, 4);
int extendedsize = BinaryConverter.ToInt32(buffer, 0, true);
reader.stream.Seek(extendedsize - 4, SeekOrigin.Current);
}
this.firstframe = reader.stream.Position;
break;
}
else
reader.stream.Seek(-9, SeekOrigin.Current);
}
}
if (version == new Version(0, 0))
{
this.isempty = true;
this.version = empty.version;
this.flags = empty.flags;
this.size = empty.size;
this.firstframe = empty.firstframe;
}
}
public MessageBroker(IDuplexStream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
_reader = new FrameReader(stream);
_writer = new FrameWriter(stream);
}
public PlainTextLogEventReader(TextReader input, string extractionPattern)
{
if (extractionPattern == null)
{
throw new ArgumentNullException(nameof(extractionPattern));
}
_nameValueExtractor = ExtractionPatternInterpreter.CreateNameValueExtractor(ExtractionPatternParser.Parse(extractionPattern));
_reader = new FrameReader(input, SpanEx.MatchedBy(_nameValueExtractor.StartMarker), TrailingLineArrivalDeadline);
}
protected override void Load(FrameReader reader)
{
_consistencyLevel = (ConsistencyLevel)reader.ReadInt16();
_received = reader.ReadInt32();
_blockFor = reader.ReadInt32();
if (_isFailure)
{
_failures = reader.ReadInt32();
}
_writeType = reader.ReadString();
}
public async Task TerminatesWhenNoLinesArePresent()
{
var reader = new FrameReader(
new StringReader(""),
SpanEx.MatchedBy(Character.Letter),
TimeSpan.FromMilliseconds(100));
var none = await reader.TryReadAsync();
Assert.False(none.HasValue);
}
protected override void Load(FrameReader reader)
{
_consistency = (ConsistencyLevel)reader.ReadInt16();
_received = reader.ReadInt32();
_blockFor = reader.ReadInt32();
if (_isFailure)
{
_failures = reader.ReadInt32();
}
_dataPresent = reader.ReadByte() != 0;
}
protected override void Load(FrameReader reader)
{
_consistency = (ConsistencyLevel) reader.ReadInt16();
_received = reader.ReadInt32();
_blockFor = reader.ReadInt32();
if (_isFailure)
{
_failures = reader.ReadInt32();
}
_dataPresent = reader.ReadByte() != 0;
}
internal OutputPrepared(ProtocolVersion protocolVersion, FrameReader reader)
{
QueryId = reader.ReadShortBytes();
if (protocolVersion.SupportsResultMetadataId())
{
ResultMetadataId = reader.ReadShortBytes();
}
Metadata = new RowSetMetadata(reader, protocolVersion.SupportsPreparedPartitionKey());
}
protected override void Load(FrameReader reader)
{
_consistencyLevel = (ConsistencyLevel) reader.ReadInt16();
_received = reader.ReadInt32();
_blockFor = reader.ReadInt32();
if (_isFailure)
{
_failures = reader.ReadInt32();
}
_writeType = reader.ReadString();
}
internal ATSITrackTimestamp(FrameReader fr)
{
sector_pointers = new List <int>();
track_nr = fr.read_ushort();
unknown2 = fr.read_ushort();
pg_id = fr.read_byte();
unknown3 = fr.read_byte();
first_pts = fr.read_uint();
len_in_pts = fr.read_uint();
padding1 = fr.read_ushort();
padding2 = fr.read_uint();
}
public void Should_Throw_Helpful_Exception_On_Unknown_Error_Code()
{
int unknownCode = int.MaxValue;
string unknownMessage = "This message should be included in the exception";
FrameReader frameReader = null; // This isn't currently needed to reproduce so set as null
// Make sure we get an exception
var caught = Assert.Catch <DriverInternalError>(() => OutputError.CreateOutputError(unknownCode, unknownMessage, frameReader));
// Verify the exception message contains the code and the message from the server
Assert.True(caught.Message.Contains(unknownCode.ToString()));
Assert.True(caught.Message.Contains(unknownMessage));
}
/// <summary>
/// Get ready for the first shot.
/// </summary>
public void AttachToReader(FrameReader reader)
{
if (_reader != null)
{
throw new InvalidOperationException("We've already attached to a reader!");
}
_reader = reader;
_reader.AddResponder(this);
// We fire this event here to avoid doing actual work in the constructor,
// and to give the caller a chance to register for the ReadyForShot event.
PrepareForNextShot();
}
public async Task can_parse_connect()
{
string input = @"CONNECT
hello:world
" + '\0';
var parser = new FrameReader(new MemoryStream(Encoding.UTF8.GetBytes(input)));
var f = await parser.Parse();
Assert.IsNotNull(f, "frame");
Assert.AreEqual("CONNECT", f.Command);
Assert.AreEqual("world", f.Headers["hello"]);
Assert.AreEqual(0, f.Body.Length, "Body.Length");
}
private async void ToggleSwitch_Toggled(object sender, RoutedEventArgs e)
{
if (sender is ToggleSwitch @switch)
{
if (@switch.IsOn)
{
await FrameReader.StartAsync();
}
else
{
await FrameReader.StopAsync();
}
}
}
internal PCM_EXTRAHEADER(FrameReader fr)
{
byte tmp;
first_audio_frame = fr.read_ushort();
padding1 = fr.read_byte();
group1_bits = (byte)(((tmp = fr.read_byte()) >> 4) & 0xf);
group2_bits = (byte)(tmp & 0xf);
group1_freq = (byte)(((tmp = fr.read_byte()) >> 4) & 0xf);
group2_freq = (byte)(tmp & 0xf);
padding2 = fr.read_byte();
channel_assignment = fr.read_byte();
padding3 = fr.read_byte();
cci = fr.read_byte();
}
public ConnectionIO(Connection connection) : base(channelNum: 0)
{
_conn = connection;
_socketHolder = new SocketHolder();
_commandOutboxEvent = new AutoResetEvent(false);
_waitingServerReply = new ManualResetEventSlim(true);
// _commandOutboxEvent = new AutoResetSuperSlimLock(false);
_commandOutbox = new ConcurrentQueue <CommandToSend>();
_cmdToSendObjPool = new ObjectPool <CommandToSend>(() => new CommandToSend(i => _cmdToSendObjPool.PutObject(i)), 200, true);
_amqpWriter = new AmqpPrimitivesWriter();
_amqpReader = new AmqpPrimitivesReader();
_frameReader = new FrameReader();
}
internal MLP_SIGNATURE(FrameReader fr)
{
byte tmp;
signature1 = fr.read_uint();
group1_bits = (byte)(((tmp = fr.read_byte()) >> 4) & 0xf);
group2_bits = (byte)(tmp & 0xf);
group1_freq = (byte)(((tmp = fr.read_byte()) >> 4) & 0xf);
group2_freq = (byte)(tmp & 0xf);
padding1 = fr.read_byte();
channel_assignment = fr.read_byte();
signature2 = fr.read_ushort();
padding2 = fr.read_uint();
bitrate = fr.read_ushort();
substreams = (byte)(fr.read_byte() & 0xf);
}
internal ATSITitle(AudioDecoder atsi, FrameReader fr)
{
this.atsi = atsi;
track_timestamp = new List <ATSITrackTimestamp>();
track_sector = new List <ATSITrackSector>();
unknown1 = fr.read_ushort();
ntracks = fr.read_byte();
nindexes = fr.read_byte();
length_pts = fr.read_uint();
unknown2 = fr.read_ushort();
unknown3 = fr.read_ushort();
track_sector_table_offset = fr.read_ushort();
unknown4 = fr.read_ushort();
}
private async Task StartOperationAsync()
{
CollectedColorFrames = new ConcurrentBag <ExampleMediaFrame>();
CollectedNonIlluminatedInfraredFrames = new ConcurrentBag <ExampleMediaFrame>();
CollectedIlluminatedInfraredFrames = new ConcurrentBag <ExampleMediaFrame>();
Stopwatch = new Stopwatch();
WrittenToDiskFramesCount = 0;
// Open the capture object to pump the frames to UI preview element
// More information, including how to keep the display on:
// https://docs.microsoft.com/en-us/windows/uwp/audio-video-camera/simple-camera-preview-access
// ExampleMediaCapture interface is based on Windows.Media.Capture.MediaCapture
// https://docs.microsoft.com/en-us/uwp/api/Windows.Media.Capture.MediaCapture
MediaCapture = new ExampleMediaCapture();
await MediaCapture.InitializeAsync();
FrameCollection = new ExampleMediaFrameCollection(MediaCapture);
FrameCollection.CollectionProgressed += FrameCollection_CollectionProgressed;
CaptureElement.Source = MediaCapture.PreviewMediaCapture;
CaptureElement.FlowDirection = MediaCapture.PreviewFlowDirection;
await MediaCapture.StartPreviewAsync();
// Open the reader object to subscribe to arriving frames
// More information:
// https://docs.microsoft.com/en-us/windows/uwp/audio-video-camera/process-media-frames-with-mediaframereader#create-a-frame-reader-for-the-frame-source
// ExampleMediaFrameReader interface is based on Windows.Media.Capture.Frames.MultiSourceMediaFrameReader
// https://docs.microsoft.com/en-us/uwp/api/windows.media.capture.frames.multisourcemediaframereader
FrameReader = await MediaCapture.CreateFrameReaderAsync();
FrameReader.AcquisitionMode = MediaFrameReaderAcquisitionMode.Buffered;
FrameReader.FrameArrived += FrameReader_FrameArrived;
// Start frame reader immediately
await FrameReader.StartAsync();
DispatcherTimer = new DispatcherTimer
{
Interval = TimeSpan.FromMilliseconds(100)
};
DispatcherTimer.Tick += DispatcherTimer_Tick;
DispatcherTimer.Start();
Stopwatch.Start();
}
private void WriteAndRead(FrameWriter writer, FrameReader reader, Input.DirectX.Identifier input, Output.Joystick.Identifier output, Axis axis, double value)
{
writer.Write(new Dictionary <Output.IIdentifier, State>
{
{ output, new State()
{
Axis = new Dictionary <Axis, double>
{
{ axis, value }
}
} }
});
Thread.Sleep(1);
var actual = reader.Read()[input].Axis[axis];
Assert.IsTrue(value <= actual + 0.001 && actual - 0.001 <= value);
}
public ZlibReader(
IFrameReader frameReader,
byte[] dictionary,
int length)
{
if (length <= 0)
{
throw new ArgumentOutOfRangeException(nameof(length), $"{length} is an invalid length of a Zlib stream");
}
_frameReader = frameReader;
_headerReader = new FrameReader(_pipe.Reader);
_dictionary = dictionary;
_length = length;
_backgroundTask = RunZlibDecompress();
}
public async Task WriteReadAckFrame()
{
var stream = new MockDuplexStream();
var writer = new FrameWriter(stream);
var request = Frame.ACK;
await writer.Write(request, CancellationToken.None);
var data = stream.Output.ToArray();
await stream.Input.WriteAsync(data, 0, data.Length);
stream.Input.Position = 0;
var reader = new FrameReader(stream);
var response = await reader.Read(CancellationToken.None);
Assert.AreEqual(request, response);
}
public async Task WriteReadDataFrame()
{
var input = new byte[] { 1, 12, 0, 4, 0, 15, 6, 49, 5, 4, 34, 0, 3, 239 };
var stream = new MockDuplexStream();
stream.Input.Write(input, 0, input.Length);
stream.Input.Position = 0;
var reader = new FrameReader(stream);
var response = (DataFrame)(await reader.Read(CancellationToken.None));
var request = new DataFrame(DataFrameType.REQ, response.Payload);
var writer = new FrameWriter(stream);
await writer.Write(request, CancellationToken.None);
var output = stream.Output.ToArray();
Assert.IsTrue(input.SequenceEqual(output));
}
public Http2Session(SecureSocket sessionSocket, ConnectionEnd end,
bool usePriorities, bool useFlowControl,
IDictionary <string, object> handshakeResult = null)
{
_ourEnd = end;
_usePriorities = usePriorities;
_useFlowControl = useFlowControl;
_handshakeHeaders = new Dictionary <string, string>(16);
ApplyHandshakeResults(handshakeResult);
if (_ourEnd == ConnectionEnd.Client)
{
_remoteEnd = ConnectionEnd.Server;
_lastId = -1; // Streams opened by client are odd
}
else
{
_remoteEnd = ConnectionEnd.Client;
_lastId = 0; // Streams opened by server are even
}
_goAwayReceived = false;
_settingsManager = new SettingsManager();
_comprProc = new CompressionProcessor(_ourEnd);
_sessionSocket = sessionSocket;
_frameReader = new FrameReader(_sessionSocket);
ActiveStreams = new ActiveStreams();
_writeQueue = new WriteQueue(_sessionSocket, ActiveStreams, _usePriorities);
OurMaxConcurrentStreams = 100; //Spec recommends value 100 by default
RemoteMaxConcurrentStreams = 100;
_flowControlManager = new FlowControlManager(this);
if (!_useFlowControl)
{
_flowControlManager.Options = (byte)FlowControlOptions.DontUseFlowControl;
}
SessionWindowSize = 0;
}
static async Task <Frame[]> ReadAllFrames(string source, TextParser <TextSpan> frameStart)
{
var reader = new FrameReader(
new StringReader(source),
frameStart,
TimeSpan.FromMilliseconds(100));
var result = new List <Frame>();
var frame = await reader.TryReadAsync();
while (frame.HasValue)
{
result.Add(frame);
frame = await reader.TryReadAsync();
}
return(result.ToArray());
}
private async void MediaCapture_FaceDetected(ExampleMediaCapture sender, FaceDetectedEventArgs args)
{
// This event is raised even when no faces are present, the argument must be inspected
if (args.ResultFrame.DetectedFaces.Any() && FrameReader != null)
{
if (PreviewOpacity == 0.0)
{
await FrameReader.StartAsync();
PreviewOpacity = 1.0;
}
// Reset the countdown to turning off camera
FrameReaderStopTrigger.Stop();
FrameReaderStopTrigger.Start();
}
UpdateSystemRelativeTime(args.ResultFrame.SystemRelativeTime);
}
unsafe int getSubstreamHeaderLen(byte[] substream_buf, int substream_off, int substream_len)
{
if (substream_len <= 4)
return(0);
fixed(byte *p = &substream_buf[substream_off])
{
var fr = new FrameReader(p, substream_len);
var hdr = new SUB_HEADER(fr);
switch (hdr.stream_id)
{
case DVDA.PCM_STREAM_ID:
case DVDA.MLP_STREAM_ID:
return(SUB_HEADER.SIZE + hdr.extra_len);
default:
return(0);
}
}
}
internal Response(Frame frame)
{
if (frame == null) throw new ArgumentNullException("frame");
if (frame.Body == null) throw new InvalidOperationException("Response body of the received frame was null");
if (!frame.Header.Flags.HasFlag(HeaderFlag.Compression) && frame.Header.BodyLength > frame.Body.Length - frame.Body.Position)
{
throw new DriverInternalError(string.Format(
"Response body length should be contained in stream: Expected {0} but was {1} (position {2})",
frame.Header.BodyLength, frame.Body.Length - frame.Body.Position, frame.Body.Position));
}
Reader = new FrameReader(frame.Body, frame.Serializer);
if (frame.Header.Flags.HasFlag(HeaderFlag.Tracing))
{
//If a response frame has the tracing flag set, the first item in its body is the trace id
var buffer = new byte[16];
Reader.Read(buffer, 0, 16);
TraceId = new Guid(TypeSerializer.GuidShuffle(buffer));
}
}
/// <summary>
/// Load or reload previews asynchronously.
/// </summary>
public async Task LoadAsync()
{
var cancelSource = new CancellationTokenSource();
CancellableTask newLoadTask = new CancellableTask(() => {
foreach (string?path in PhotoFiles.GetPaths())
{
cancelSource.Token.ThrowIfCancellationRequested();
BitmapImage?thumb;
using (FrameReader reader = new FrameReader(path)) {
try {
thumb = reader.ReadThumbnail();
} catch (Exception) {
thumb = null;
}
}
if (thumb != null)
{
var preview = new PhotoPreview(thumb, path);
dispatcher.Invoke(() =>
collection.Add(preview)
);
}
}
}, cancelSource);
var prevTask = Interlocked.Exchange(ref loadTask, newLoadTask);
if (prevTask != null)
{
await prevTask.Cancel();
}
collection.Clear();
collection.Add(defaultPreview);
newLoadTask.Start();
}
protected override void Load(FrameReader cb)
{
short len = cb.ReadInt16();
_info.UnknownId = new byte[len];
cb.Read(_info.UnknownId, 0, len);
}
IdentifyResponse Identify(NetworkStream stream, FrameReader reader)
{
var identify = new Identify(_options);
SendCommandToStream(stream, identify);
var frame = reader.ReadFrame();
if (frame.Type != FrameType.Result)
{
throw new InvalidOperationException("Unexpected frame type after IDENTIFY");
}
return identify.ParseIdentifyResponse(frame.Data);
}
void Handshake(NetworkStream stream, FrameReader reader)
{
// Initiate the V2 protocol
stream.Write(MAGIC_V2, 0, MAGIC_V2.Length);
_identifyResponse = Identify(stream, reader);
if (_identifyResponse.AuthRequired)
{
Dispose();
throw new NotSupportedException("Authorization is not supported");
}
SendCommandToStream(stream, new Subscribe(_options.Topic, _options.Channel));
}
void WorkerLoop(object messageHandler)
{
MessageHandler handler = (MessageHandler)messageHandler;
bool firstConnectionAttempt = true;
TcpClient client = null;
FrameReader reader = null;
IBackoffLimiter backoffLimiter = null;
IDisposable cancellationRegistration = Disposable.Empty;
while (true)
{
try
{
if (_connectionClosedSource.IsCancellationRequested)
{
return;
}
if (!Connected)
{
lock (_connectionSwapLock)
{
if (firstConnectionAttempt)
{
firstConnectionAttempt = false;
}
else
{
if (backoffLimiter == null)
backoffLimiter = _backoffStrategy.Create();
TimeSpan delay;
if (backoffLimiter.ShouldReconnect(out delay))
{
OnInternalMessage("Delaying {0} ms before reconnecting", (int)delay.TotalMilliseconds);
Thread.Sleep(delay);
}
else
{
// We give up
OnInternalMessage("Abandoning connection");
Dispose();
return;
}
}
lock (_connectionSwapInProgressLock)
{
CancellationToken cancellationToken;
lock (_disposeLock)
{
if (_disposed) return;
if (client != null)
{
cancellationRegistration.Dispose();
((IDisposable)client).Dispose();
}
cancellationToken = _connectionClosedSource.Token;
}
OnInternalMessage("TCP client starting");
client = new TcpClient(_endPoint.Host, _endPoint.Port);
cancellationRegistration = cancellationToken.Register(() => ((IDisposable)client).Dispose(), false);
Connected = true;
OnInternalMessage("TCP client started");
_stream = client.GetStream();
reader = new FrameReader(_stream);
Handshake(_stream, reader);
_firstConnection.TrySetResult(true);
// Start a new backoff cycle next time we disconnect
backoffLimiter = null;
_nextReconnectionTaskSource.SetResult(true);
_nextReconnectionTaskSource = new TaskCompletionSource<bool>();
}
}
}
Frame frame;
while ((frame = reader.ReadFrame()) != null)
{
if (frame.Type == FrameType.Result)
{
if (HEARTBEAT.SequenceEqual(frame.Data))
{
OnInternalMessage("Heartbeat");
SendCommandAsync(new Nop())
.ContinueWith(t => Dispose(), TaskContinuationOptions.OnlyOnFaulted);
}
else
{
OnInternalMessage("Received result. Length = {0}", frame.MessageSize);
}
}
else if (frame.Type == FrameType.Message)
{
OnInternalMessage("Received message. Length = {0}", frame.MessageSize);
var message = new Message(frame, this);
// TODO: Rethink this
ThreadPool.QueueUserWorkItem(new WaitCallback(_ => { handler(message); }));
}
else if (frame.Type == FrameType.Error)
{
string errorString;
try
{
errorString = Encoding.ASCII.GetString(frame.Data);
}
catch
{
errorString = BitConverter.ToString(frame.Data);
}
OnInternalMessage("Received error. Message = {0}", errorString);
}
else
{
OnInternalMessage("Unknown message type: {0}", frame.Type);
throw new InvalidOperationException("Unknown message type " + frame.Type);
}
}
}
catch (ObjectDisposedException ex)
{
OnInternalMessage("Exiting worker loop due to disposal. Message = {0}", ex.Message);
Connected = false;
return;
}
catch (IOException ex)
{
if (!_disposed) OnInternalMessage("EXCEPTION: {0}", ex.Message);
Connected = false;
continue;
}
catch (SocketException ex)
{
if (!_disposed) OnInternalMessage("EXCEPTION: {0}", ex.Message);
Connected = false;
continue;
}
}
}
public static Task<DS4CalibrationRecord> CalibrateAsync(FrameReader reader)
{
#if DSAPI
return Task<DS4CalibrationRecord>.Run(() => Calibrator.Calibrate(reader.DSAPI));
#else
return Task<DS4CalibrationRecord>.Run(() => Calibrator.Calibrate(reader.Device));
#endif
}
protected override void Load(FrameReader cb)
{
_info.Ks = cb.ReadString();
_info.Table = cb.ReadString();
}
protected override void Load(FrameReader cb)
{
_consistency = (ConsistencyLevel) cb.ReadInt16();
_required = cb.ReadInt32();
_alive = cb.ReadInt32();
}
protected override void Load(FrameReader reader)
{
}
