public DataBlockContainer(ContainerHeader header, Stream payload, StillImageDevice.TransferCallback callback) { Header = header; Payload = new byte[Header.PayloadLength]; // int readnum = payload.Read(Payload, 0, Header.PayloadLength); int numBytes = 0; while (numBytes != Header.PayloadLength) { numBytes += payload.Read(Payload, numBytes, Header.PayloadLength - numBytes); if (callback != null) callback(Header.PayloadLength, numBytes); } }
public void Read(Stream s, StillImageDevice.TransferCallback callback) { this.TransactionID = (uint)(readByte(s) | (readByte(s) << 8) | (readByte(s) << 16) | (readByte(s) << 24)); Data = new byte[Header.Length - 8 - 4]; int numBytes = 0; while (numBytes != Header.Length-8-4) { numBytes += s.Read(Data, numBytes, (int)(Header.Length - 8 - 4 - numBytes));// payload.Read(Payload, numBytes, Header.PayloadLength - numBytes); if (callback != null) callback((int) Header.Length, numBytes); } }
public IPtpIpCommand Read(StillImageDevice.TransferCallback callback=null) { var header = new PtpIpHeader(); header.Read(_inerStream); switch ((PtpIpContainerType) header.Type) { case PtpIpContainerType.Init_Command_Request: break; case PtpIpContainerType.Init_Command_Ack: var initcommand = new InitCommandAck() {Header = header}; initcommand.Read(_inerStream); return initcommand; case PtpIpContainerType.Init_Event_Request: break; case PtpIpContainerType.Init_Event_Ack: break; case PtpIpContainerType.Init_Fail: break; case PtpIpContainerType.Cmd_Request: break; case PtpIpContainerType.Cmd_Response: var cmdresp = new CmdResponse() {Header = header}; cmdresp.Read(_inerStream); return cmdresp; case PtpIpContainerType.Event: break; case PtpIpContainerType.Start_Data_Packet: var stardatares = new StartDataPacket() {Header = header}; stardatares.Read(_inerStream); return stardatares; case PtpIpContainerType.Data_Packet: var data = new DataPacket() {Header = header}; data.Read(_inerStream); return data; case PtpIpContainerType.Cancel_Transaction: break; case PtpIpContainerType.End_Data_Packet: var enddata = new EndDataPacket() {Header = header}; enddata.Read(_inerStream, callback); return enddata; case PtpIpContainerType.Ping: break; case PtpIpContainerType.Pong: break; default: throw new ArgumentOutOfRangeException(); } return null; }
public MTPDataResponse ExecuteReadBigData(uint code,Stream stream ,StillImageDevice.TransferCallback callback, params uint[] parameters) { lock (_syncRoot) { ReconnectIfNeeded(); DataBlockContainer data; var res = new MTPDataResponse(); _client.Write(new CommandBlockContainer((int)code, parameters)); int len = _client.ReadInt(); Container resp = _client.ReadContainer(callback); if (resp.Header.Length >= len - 4) { return new MTPDataResponse() { ErrorCode = (uint)resp.Header.Code }; } data = (DataBlockContainer)resp; resp = _client.ReadContainer(); return new MTPDataResponse() { Data = data.Payload, ErrorCode = (uint)data.Header.Code }; } }
public MTPDataResponse ExecuteReadBigData(uint code,Stream stream, StillImageDevice.TransferCallback callback, params uint[] parameters) { lock (_locker) { var cmd = new CmdRequest(code) { Parameters = parameters }; _client.Write(cmd); var res1 = _client.Read(); var response = res1 as CmdResponse; if (response != null) { return new MTPDataResponse() { ErrorCode = (uint)response.Code }; } var response1 = res1 as StartDataPacket; var res2 = _client.Read(callback); var res3 = (EndDataPacket)res2; var res4 = _client.Read(); return new MTPDataResponse() { Data = res3.Data }; } }
public MTPDataResponse ExecuteReadBigData(uint code, StillImageDevice.TransferCallback callback, params uint[] parameters) { throw new NotImplementedException(); }
public override bool Init(DeviceDescriptor deviceDescriptor) { StillImageDevice = new StillImageDevice(deviceDescriptor.WpdId); StillImageDevice.ConnectToDevice(AppName, AppMajorVersionNumber, AppMinorVersionNumber); StillImageDevice.DeviceEvent += _stillImageDevice_DeviceEvent; DeviceName = StillImageDevice.Model; Manufacturer = StillImageDevice.Manufacturer; Capabilities.Add(CapabilityEnum.Bulb); Capabilities.Add(CapabilityEnum.LiveView); InitShutterSpeed(); IsConnected = true; ExecuteWithNoData(CONST_CMD_CANON_EOS_SetRemoteMode, 1); ExecuteWithNoData(CONST_CMD_CANON_EOS_SetEventMode, 1); _timer.Start(); return true; }
protected Container getContainer(bool synchronized, StillImageDevice.TransferCallback callback) { var header = new ContainerHeader(_inerStream); switch (header.ContainerType) { case ContainerType.DataBlock: return new DataBlockContainer(header, _inerStream, callback); case ContainerType.ResponseBlock: if (synchronized) Monitor.Exit(_commandLock); return new ResponseBlockContainer(header, _inerStream); //Give current instance as stream, because we need keep track on the distance to next header case ContainerType.CommandBlock: case ContainerType.EventBlock: throw new Exception("Invalid container type. " + header.ContainerType); } throw new Exception("Unkown container type"); }
public virtual Container ReadContainer(StillImageDevice.TransferCallback callback = null) { Container result = getContainer(false, callback); return result; }
public override bool Init(DeviceDescriptor deviceDescriptor) { StillImageDevice = new StillImageDevice(deviceDescriptor.WpdId); StillImageDevice.ConnectToDevice(AppName, AppMajorVersionNumber, AppMinorVersionNumber); StillImageDevice.DeviceEvent += StillImageDevice_DeviceEvent; IsConnected = true; return true; }
public override bool Init(DeviceDescriptor deviceDescriptor) { try { IsBusy = true; Capabilities.Add(CapabilityEnum.CaptureInRam); Capabilities.Add(CapabilityEnum.CaptureNoAf); StillImageDevice = new StillImageDevice(deviceDescriptor.WpdId); StillImageDevice.ConnectToDevice(AppName, AppMajorVersionNumber, AppMinorVersionNumber); StillImageDevice.DeviceEvent += _stillImageDevice_DeviceEvent; HaveLiveView = true; DeviceReady(); DeviceName = StillImageDevice.Model; Manufacturer = StillImageDevice.Manufacturer; IsConnected = true; CaptureInSdRam = true; PropertyChanged += NikonBase_PropertyChanged; var ser = StillImageDevice.SerialNumber; if (ser != null && ser.Length >= 7) { SerialNumber = StillImageDevice.SerialNumber.Substring(0, 7); } // load advanced properties in a separated thread to speed up camera connection var thread = new Thread(LoadProperties) {Priority = ThreadPriority.Lowest}; thread.Start(); } catch (Exception exception) { Log.Error("Error initialize device", exception); } return true; }
private void DisconnectCamera(StillImageDevice device) { DeviceDescriptor descriptor = _deviceEnumerator.GetByWpdId(device.DeviceId); if (descriptor != null) { descriptor.CameraDevice.PhotoCaptured -= cameraDevice_PhotoCaptured; descriptor.CameraDevice.CameraDisconnected -= cameraDevice_CameraDisconnected; ConnectedDevices.Remove(descriptor.CameraDevice); StaticHelper.Instance.SystemMessage = "Camera disconnected :" + descriptor.CameraDevice.DeviceName; Log.Debug("===========Camera disconnected=============="); Log.Debug("Name :" + descriptor.CameraDevice.DeviceName); PortableDeviceCollection.Instance.RemoveDevice(device.DeviceId); device.IsConnected = false; if (SelectedCameraDevice == descriptor.CameraDevice) { SelectedCameraDevice = ConnectedDevices.Count > 0 ? ConnectedDevices[0] : new NotConnectedCameraDevice(); } descriptor.CameraDevice.Close(); _deviceEnumerator.Remove(descriptor); _deviceEnumerator.RemoveDisconnected(); } RemoveDisconnected(); }