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