public MTPDataResponse ExecuteReadBigData(uint code, 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 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 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((uint)Header.PayloadLength, (uint)numBytes);
}
}
}
public void Read(Stream s, StillImageDevice.TransferCallback callback, Stream outStream)
{
this.TransactionID = (uint)(readByte(s) | (readByte(s) << 8) | (readByte(s) << 16) | (readByte(s) << 24));
//Data = new byte[Header.Length - 8 - 4];
byte[] buff = new byte[102400];
int numBytes = 0;
while (numBytes != Header.Length - 8 - 4)
{
var bytesRead =
s.Read(buff, 0, buff.Length); // payload.Read(Payload, numBytes, Header.PayloadLength - numBytes);
outStream.Write(buff, 0, bytesRead);
numBytes += bytesRead;
if (callback != null)
{
callback((int)Header.Length, numBytes);
}
}
}
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 MTPDataResponse ExecuteReadBigData(uint code, StillImageDevice.TransferCallback callback, params uint[] parameters)
{
throw new NotImplementedException();
}
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 virtual Container ReadContainer(StillImageDevice.TransferCallback callback = null)
{
Container result = getContainer(false, callback);
return(result);
}
