internal static EosLiveImage CreateFromStream(IntPtr stream)
{
IntPtr imagePtr;
Util.Assert(Edsdk.EdsCreateEvfImageRefCdecl(stream, out imagePtr), "Failed to create evf image.");
return(new EosLiveImage(imagePtr));
}
private static IntPtr CreateMemoryStream(uint size)
{
IntPtr stream;
Util.Assert(Edsdk.EdsCreateMemoryStream(size, out stream), "Failed to create memory stream");
return(stream);
}
internal EosCamera(IntPtr camera)
: base(camera)
{
Util.Assert(Edsdk.EdsGetDeviceInfo(this.Handle, out _deviceInfo),
"Failed to get device info.");
//this.SetEventHandlers();
this.EnsureOpenSession();
}
private static IntPtr CreateFileStream(string imageFilePath)
{
IntPtr stream;
Util.Assert(Edsdk.EdsCreateFileStream(imageFilePath, Edsdk.EdsFileCreateDisposition.CreateAlways,
Edsdk.EdsAccess.ReadWrite, out stream), "Failed to create file stream");
return(stream);
}
private uint SendCommand(uint command, int parameter = 0)
{
lock (_locker)
{
this.EnsureOpenSession();
return(Edsdk.EdsSendCommand(this.Handle, command, parameter));
}
}
private static void DestroyStream(ref IntPtr stream)
{
if (stream != IntPtr.Zero)
{
Util.Assert(Edsdk.EdsRelease(stream), "Failed to release stream");
stream = IntPtr.Zero;
}
}
protected internal override void DisposeUnmanaged()
{
if (_cameraList != IntPtr.Zero)
{
Edsdk.EdsRelease(_cameraList);
}
base.DisposeUnmanaged();
}
private void Unlock()
{
if (this.IsLocked)
{
Edsdk.EdsSendStatusCommand(this.Handle, Edsdk.CameraState_UIUnLock);
this.IsLocked = false;
}
}
protected internal override void DisposeUnmanaged()
{
if (this.IsSessionOpen)
{
Edsdk.EdsCloseSession(this.Handle);
}
base.DisposeUnmanaged();
}
protected internal override void DisposeUnmanaged()
{
if (_handle != IntPtr.Zero)
{
Edsdk.EdsRelease(_handle);
}
base.DisposeUnmanaged();
}
private void EnsureOpenSession()
{
this.CheckDisposed();
if (!this.IsSessionOpen)
{
Util.Assert(Edsdk.EdsOpenSession(this.Handle), "Failed to open session.");
this.IsSessionOpen = true;
}
}
public EosImageEventArgs TransportAsFileName(IntPtr directoryItem, string imagePath, IntPtr context)
{
var directoryItemInfo = GetDirectoryItemInfo(directoryItem);
var stream = CreateFileStream(imagePath);
Edsdk.EdsSetProgressCallback(stream, progress, Edsdk.EdsProgressOption.Periodically, context);
Transport(directoryItem, directoryItemInfo.Size, stream, true);
return(new EosFileImageEventArgs(imagePath));
}
public Edsdk.EdsPropertyDesc GetPropertyDescription(uint propertyId)
{
return(this.ExecuteGetter(() =>
{
Edsdk.EdsPropertyDesc desc;
Util.Assert(Edsdk.EdsGetPropertyDesc(this.Handle, propertyId, out desc),
string.Format("Failed to get property description for data: propertyId {0}", propertyId), propertyId);
return desc;
}));
}
protected string GetPropertyStringData(uint propertyId)
{
return(this.ExecuteGetter(() =>
{
string data;
Util.Assert(Edsdk.EdsGetPropertyData(this.Handle, propertyId, 0, out data),
string.Format("Failed to get property string data: propertyId {0}", propertyId), propertyId);
return data;
}));
}
private void Lock()
{
this.CheckDisposed();
if (!this.IsLocked)
{
Util.Assert(Edsdk.EdsSendStatusCommand(this.Handle, Edsdk.CameraState_UILock),
"Failed to lock camera.");
this.IsLocked = true;
}
}
public void Unlock()
{
lock (_locker)
{
if (this.IsLocked)
{
Edsdk.EdsSendStatusCommand(this.Handle, Edsdk.CameraState_UIUnLock, 0);
this.IsLocked = false;
}
}
}
internal int GetPropertyDataSize(uint propertyId, Edsdk.EdsDataType expectedDataType)
{
return(this.ExecuteGetter(() =>
{
int dataSize;
Edsdk.EdsDataType dataType;
Util.Assert(Edsdk.EdsGetPropertySize(this.Handle, propertyId, 0, out dataType, out dataSize),
"Failed to get property size.", propertyId);
//Util.AssertIf(expectedDataType != dataType, "DataType mismatch: Expected <{0}>, Actual <{1}>", expectedDataType, dataType);
return dataSize;
}));
}
private bool DownloadEvf()
{
// Do not download if pauseUpdate requested
if (_pauseLiveViewRequested)
{
return(true);
}
if ((this.LiveViewDevice & EosLiveViewDevice.Host) == EosLiveViewDevice.None || _cancelLiveViewRequested)
{
return(false);
}
lock (_locker)
{
var memoryStream = IntPtr.Zero;
try
{
Util.Assert(Edsdk.EdsCreateMemoryStream(0, out memoryStream), "Failed to create memory stream.");
using (var image = EosLiveImage.CreateFromStream(memoryStream))
{
Util.Assert(Edsdk.EdsDownloadEvfImage(this.Handle, image.Handle),
"Failed to download evf image.");
var converter = new EosConverter();
this.OnLiveViewUpdate(
new EosLiveImageEventArgs(converter.ConvertImageStreamToBytes(memoryStream))
{
Zoom = image.Zoom,
ZommBounds = image.ZoomBounds,
ImagePosition = image.ImagePosition,
ImageSize = image.Size
//Histogram = image.Histogram,
});
}
}
catch (EosException eosEx)
{
//if (eosEx.EosErrorCode != EosErrorCode.DeviceBusy && eosEx.EosErrorCode != EosErrorCode.ObjectNotReady)
// throw;
}
finally
{
if (memoryStream != IntPtr.Zero)
{
Edsdk.EdsRelease(memoryStream);
}
}
}
return(true);
}
private void OnObjectEventVolumeInfoChanged(IntPtr sender)
{
Edsdk.EdsVolumeInfo volumeInfo;
Util.Assert(Edsdk.EdsGetVolumeInfo(sender, out volumeInfo), "Failed to get volume info.");
this.OnVolumeInfoChanged(new EosVolumeInfoEventArgs(new EosVolumeInfo
{
Access = volumeInfo.Access,
FreeSpaceInBytes = volumeInfo.FreeSpaceInBytes,
MaxCapacityInBytes = volumeInfo.MaxCapacity,
StorageType = volumeInfo.StorageType,
VolumeLabel = volumeInfo.szVolumeLabel
}));
}
protected internal override void DisposeUnmanaged()
{
lock (__referenceLock)
{
if (__referenceCount > 0)
{
if (--__referenceCount == 0)
{
Edsdk.EdsTerminateSDK();
}
}
}
base.DisposeUnmanaged();
}
public void SetEventHandlers()
{
_edsStateEventHandler = this.HandleStateEvent;
Util.Assert(Edsdk.EdsSetCameraStateEventHandler(this.Handle, Edsdk.StateEvent_All,
_edsStateEventHandler, IntPtr.Zero), "Failed to set state handler.");
_edsObjectEventHandler = this.HandleObjectEvent;
Util.Assert(Edsdk.EdsSetObjectEventHandler(this.Handle, Edsdk.ObjectEvent_All,
_edsObjectEventHandler, IntPtr.Zero), "Failed to set object handler.");
_edsPropertyEventHandler = this.HandlePropertyEvent;
Util.Assert(Edsdk.EdsSetPropertyEventHandler(this.Handle, Edsdk.PropertyEvent_All,
_edsPropertyEventHandler, IntPtr.Zero), "Failed to set object handler.");
}
public byte[] ConvertImageStreamToBytes(IntPtr imageStream)
{
IntPtr imagePtr;
Util.Assert(Edsdk.EdsGetPointer(imageStream, out imagePtr), "Failed to get image pointer.");
uint imageLen;
Util.Assert(Edsdk.EdsGetLength(imageStream, out imageLen), "Failed to get image pointer length.");
var bytes = new byte[imageLen];
Marshal.Copy(imagePtr, bytes, 0, bytes.Length);
return(bytes);
}
protected void SetPropertyStringData(uint propertyId, string data, int maxByteLength)
{
this.ExecuteSetter(() =>
{
var bytes = Util.ConvertStringToBytesWithNullByteAtEnd(data);
if (bytes.Length > maxByteLength)
{
throw new ArgumentException(string.Format("'{0}' converted to bytes is longer than {1}.", data, maxByteLength), "data");
}
Util.Assert(Edsdk.EdsSetPropertyData(this.Handle, propertyId, 0, bytes.Length, bytes),
string.Format("Failed to set property string data: propertyId {0}, data {1}", propertyId, data),
propertyId, data);
});
}
internal void SetPropertyStruct <T>(uint propertyId, T data) where T : struct
{
this.ExecuteSetter(() =>
{
try
{
Util.Assert(Edsdk.EdsSetPropertyData(this.Handle, propertyId, 0, Marshal.SizeOf((object)data), (object)data),
string.Format("Failed to set property string data: propertyId {0}, data {1}", propertyId, data),
propertyId, data);
}
finally
{
}
});
}
internal T GetPropertyStruct <T>(uint propertyId, Edsdk.EdsDataType expectedDataType) where T : struct
{
return(this.ExecuteGetter(() =>
{
var dataSize = this.GetPropertyDataSize(propertyId, expectedDataType);
var ptr = Marshal.AllocHGlobal(dataSize);
try
{
Util.Assert(Edsdk.EdsGetPropertyData(this.Handle, propertyId, 0, dataSize, ptr),
"Failed to get required struct.", propertyId);
return (T)Marshal.PtrToStructure(ptr, typeof(T));
}
finally
{
Marshal.FreeHGlobal(ptr);
}
}));
}
/// <summary>
/// Gets the <see cref="Canon.Eos.Framework.EosCamera"/> at the specified index.
/// </summary>
public EosCamera this[int index]
{
get
{
this.CheckDisposed();
if (index < 0 || index >= this.Count)
{
throw new IndexOutOfRangeException();
}
IntPtr camera;
Util.Assert(Edsdk.EdsGetChildAtIndex(_cameraList, index, out camera), string.Format("Failed to get camera #{0}.", index + 1));
if (camera == IntPtr.Zero)
{
throw new EosException(Edsdk.EDS_ERR_DEVICE_NOT_FOUND, string.Format("Failed to get camera #{0}.", index + 1));
}
return(new EosCamera(camera));
}
}
private static void Download(IntPtr directoryItem, uint size, IntPtr stream)
{
if (stream == IntPtr.Zero)
{
return;
}
try
{
Util.Assert(Edsdk.EdsDownload(directoryItem, size, stream), "Failed to download to stream");
Util.Assert(Edsdk.EdsDownloadComplete(directoryItem), "Failed to complete download");
}
catch (EosException)
{
throw;
}
catch (Exception ex)
{
throw new EosException(-1, "Unexpected exception while downloading.", ex);
}
}
public EosMemoryImageEventArgs TransportInMemory(IntPtr directoryItem, IntPtr context)
{
var directoryItemInfo = GetDirectoryItemInfo(directoryItem);
var stream = CreateMemoryStream(directoryItemInfo.Size);
try
{
Edsdk.EdsSetProgressCallback(stream, progress, Edsdk.EdsProgressOption.Periodically, context);
Transport(directoryItem, directoryItemInfo.Size, stream, false);
var converter = new EosConverter();
return(new EosMemoryImageEventArgs(converter.ConvertImageStreamToBytes(stream))
{
FileName = directoryItemInfo.szFileName
});
}
finally
{
DestroyStream(ref stream);
}
}
private void ChangePicturesSaveLocation(SaveLocation saveLocation)
{
this.CheckDisposed();
this.EnsureOpenSession();
Util.Assert(Edsdk.EdsSetPropertyData(this.Handle, Edsdk.PropID_SaveTo, 0, Marshal.SizeOf(typeof(int)),
(int)saveLocation), "Failed to set SaveTo location.");
if (!this.IsLegacy)
{
this.LockAndExceute(() =>
{
var capacity = new Edsdk.EdsCapacity {
NumberOfFreeClusters = 0x7FFFFFFF, BytesPerSector = 0x1000, Reset = 1
};
Util.Assert(Edsdk.EdsSetCapacity(this.Handle, capacity), "Failed to set capacity.");
});
}
}
protected long[] GetPropertyIntegerArrayData(uint propertyId)
{
return(this.ExecuteGetter(() =>
{
var dataSize = this.GetPropertyDataSize(propertyId, Edsdk.EdsDataType.UInt32_Array);
var ptr = Marshal.AllocHGlobal(dataSize);
try
{
Util.Assert(Edsdk.EdsGetPropertyData(this.Handle, propertyId, 0, dataSize, ptr),
"Failed to get required struct.", propertyId);
var signed = new int[dataSize / Marshal.SizeOf(typeof(uint))];
Marshal.Copy(ptr, signed, 0, signed.Length);
return signed.Select(i => (long)(uint)i).ToArray();
}
finally
{
Marshal.FreeHGlobal(ptr);
}
}));
}
