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();
}
