private void CapturePhoto(object sender, EventArgs e)
{
ToogleButtons(false);
var settingKeys = new object[]
{
AVVideo.CodecKey,
AVVideo.CompressionPropertiesKey,
};
var settingObjects = new object[]
{
new NSString("jpeg"),
new NSDictionary(AVVideo.QualityKey, 1),
};
var settingsDictionary = NSDictionary <NSString, NSObject> .FromObjectsAndKeys(settingObjects, settingKeys);
var settings = AVCapturePhotoSettings.FromFormat(settingsDictionary);
if (_capturePhotoOutput.SupportedFlashModes.Length > 0 && _captureDeviceInput.Device.Position == AVCaptureDevicePosition.Back)
{
settings.FlashMode = _flashMode;
}
orientationOnPhoto = currentOrientation;
_capturePhotoOutput.CapturePhoto(settings, this);
}
private void CapturePhoto()
{
var photoSettings = AVCapturePhotoSettings.Create();
photoSettings.IsHighResolutionPhotoEnabled = true;
_photoOutput.CapturePhoto(photoSettings, this);
}
private void CapturePhoto(object sender, EventArgs e)
{
var settingKeys = new object[]
{
AVVideo.CodecKey,
AVVideo.CompressionPropertiesKey,
};
var settingObjects = new object[]
{
new NSString("jpeg"),
new NSDictionary(AVVideo.QualityKey, 0.5),
};
var settingsDictionary = NSDictionary <NSString, NSObject> .FromObjectsAndKeys(settingObjects, settingKeys);
var settings = AVCapturePhotoSettings.FromFormat(settingsDictionary);
if (_captureDeviceInput.Device.Position == AVCaptureDevicePosition.Back)
{
settings.FlashMode = AVCaptureFlashMode.Auto;
}
_capturePhotoOutput.CapturePhoto(settings, this);
}
public void HandleAction()
{
var photoSettings = AVCapturePhotoSettings.Create();
var photoPreviewType = photoSettings.AvailablePreviewPhotoPixelFormatTypes.First();
if (photoPreviewType != null)
{
photoSettings.PreviewPhotoFormat = new NSDictionary <NSString, NSObject>(CVPixelBuffer.PixelFormatTypeKey, photoPreviewType);
_photoOutput.CapturePhoto(photoSettings, this);
}
}
/// <summary
/// <summary>
/// 写真撮影をします。
/// </summary>
public async static Task TakePhoto()
{
// カメラの設定
PhotoSettings = AVCapturePhotoSettings.Create();
PhotoSettings.DepthDataFiltered = false;
var CaptureDelegate = new PhotoCaptureDelegate();
// 写真の撮影
await Task.Run(() =>
{
PhotoOutput.CapturePhoto(PhotoSettings, CaptureDelegate);
});
}
public void CapturePhoto(LivePhotoMode livePhotoMode, bool saveToPhotoLibrary)
{
_sessionQueue.DispatchAsync(() =>
{
var photoSettings = AVCapturePhotoSettings.Create();
if (_photoOutput.SupportedFlashModes.Contains(NSNumber.FromInt32((int)AVCaptureFlashMode.Auto)))
{
photoSettings.FlashMode = AVCaptureFlashMode.Auto;
}
photoSettings.IsHighResolutionPhotoEnabled = true;
var availablePhotoCodecTypes = photoSettings.AvailableEmbeddedThumbnailPhotoCodecTypes;
if (UIDevice.CurrentDevice.CheckSystemVersion(10, 0) && availablePhotoCodecTypes.Length > 0)
{
photoSettings.EmbeddedThumbnailPhotoFormat = new NSMutableDictionary
{
{ AVVideo.CodecKey, availablePhotoCodecTypes[0].GetConstant() }
};
}
if (livePhotoMode == LivePhotoMode.On)
{
if (_presetConfiguration == SessionPresetConfiguration.LivePhotos &&
_photoOutput.IsLivePhotoCaptureSupported)
{
photoSettings.LivePhotoMovieFileUrl =
NSUrl.CreateFileUrl(new[] { Path.GetTempPath(), $"{Guid.NewGuid()}.mov" });
}
else
{
Console.WriteLine(
"capture session: warning - trying to capture live photo but it's not supported by current configuration, capturing regular photo instead");
}
}
// Use a separate object for the photo capture delegate to isolate each capture life cycle.
var photoCaptureDelegate = new PhotoCaptureDelegate(photoSettings,
() => WillCapturePhotoAnimationAction(photoSettings),
CapturingLivePhotoAction, CapturingCompletedAction)
{
ShouldSavePhotoToLibrary = saveToPhotoLibrary
};
_photoOutput.CapturePhoto(photoSettings, photoCaptureDelegate);
});
}
private void HandleCapture()
{
if (captureOutput == null)
{
return;
}
var photoSettings = AVCapturePhotoSettings.Create();
photoSettings.IsAutoStillImageStabilizationEnabled = true;
photoSettings.IsHighResolutionPhotoEnabled = true;
photoSettings.FlashMode = flashMode;
captureOutput.CapturePhoto(photoSettings, this);
}
public void Capture()
{
// Create Photo Settings
photoSettings = AVCapturePhotoSettings.FromFormat(new NSDictionary <NSString, NSObject>(AVVideo.CodecKey, AVVideo.CodecJPEG));
photoSettings.IsHighResolutionPhotoEnabled = true;
photoSettings.IsDepthDataDeliveryEnabled(false);
if (photoSettings.AvailablePreviewPhotoPixelFormatTypes.Count() > 0)
{
photoSettings.PreviewPhotoFormat = new NSDictionary <NSString, NSObject>(CVPixelBuffer.PixelFormatTypeKey, photoSettings.AvailablePreviewPhotoPixelFormatTypes.First());
}
// Use a separate object for the photo capture delegate to isolate each capture life cycle.
photoCaptureDelegate = new XCameraPhotoCaptureDelegate(photoSettings, PhotoCapturedHandler);
photoOutput.CapturePhoto(photoSettings, photoCaptureDelegate);
}
partial void TakePhoto(UIButton sender)
{
AVCaptureVideoOrientation layerOrientation = videoPreviewLayer.Connection.VideoOrientation;
if (isMovie)
{
ShutterButton.Enabled = false; // disable until recording starts/stops
if (!movieOutput.Recording)
{
// set up recording
if (UIDevice.CurrentDevice.IsMultitaskingSupported)
{
backgroundRecordingId = UIApplication.SharedApplication.BeginBackgroundTask(null);
}
AVCaptureConnection connection = movieOutput?.ConnectionFromMediaType(AVMediaType.Video);
if (connection != null)
{
connection.VideoOrientation = layerOrientation;
}
SetPaths(".mov");
movieOutput.StartRecordingToOutputFile(NSUrl.FromFilename(filePath), this);
}
else
{
// finish recording
movieOutput.StopRecording();
}
}
else
{
AVCapturePhotoSettings photoSettings = AVCapturePhotoSettings.Create();
// The first format in the array is the preferred format
if (photoSettings.AvailablePreviewPhotoPixelFormatTypes.Length > 0)
{
photoSettings.PreviewPhotoFormat = new NSDictionary <NSString, NSObject>(CVPixelBuffer.PixelFormatTypeKey, photoSettings.AvailablePreviewPhotoPixelFormatTypes[0]);
}
stillImageOutput.CapturePhoto(photoSettings, this);
}
}
public async Task CapturePhotoAsync(string path)
{
var settings = AVCapturePhotoSettings.FromFormat(NSDictionary <NSString, NSObject> .FromObjectsAndKeys(
new object[]
{
AVVideo.CodecJPEG,
new NSDictionary(AVVideo.QualityKey, 0.9)
},
new object[]
{
AVVideo.CodecKey,
AVVideo.CompressionPropertiesKey
}));
_photoCapturePath = path;
photoOutput.CapturePhoto(settings, this);
while (_photoCapturePath != null)
{
await Task.Yield();
}
}
private void CapturePhoto(object sender, EventArgs e)
{
var settingKeys = new object[]
{
AVVideo.CodecKey,
AVVideo.CompressionPropertiesKey,
};
var settingObjects = new object[]
{
new NSString("jpeg"),
new NSDictionary(AVVideo.QualityKey, 0.5),
};
var settingsDictionary = NSDictionary <NSString, NSObject> .FromObjectsAndKeys(settingObjects, settingKeys);
var settings = AVCapturePhotoSettings.FromFormat(settingsDictionary);
settings.FlashMode = AVCaptureFlashMode.Auto;
//_photoOrientation = UIDevice.CurrentDevice.Orientation;
_capturePhotoOutput.CapturePhoto(settings, this);
}
void CapturePhoto(NSObject sender)
{
/*
* Retrieve the video preview layer's video orientation on the main queue before
* entering the session queue. We do this to ensure UI elements are accessed on
* the main thread and session configuration is done on the session queue.
*/
var videoPreviewLayerVideoOrientation = VideoPreviewLayer.Connection.VideoOrientation;
sessionQueue.DispatchAsync(() =>
{
// Update the photo output's connection to match the video orientation of the video preview layer.
var photoOutputConnection = photoOutput.ConnectionFromMediaType(AVMediaType.Video);
photoOutputConnection.VideoOrientation = videoPreviewLayerVideoOrientation;
AVCapturePhotoSettings photoSettings;
// Capture HEIF photo when supported, with flash set to auto and high resolution photo enabled.
if (photoOutput.AvailablePhotoCodecTypes.Where(codec => codec == AVVideo2.CodecHEVC).Any())
{
photoSettings = AVCapturePhotoSettings.FromFormat(new NSDictionary <NSString, NSObject>(AVVideo.CodecKey, AVVideo2.CodecHEVC));
}
else
{
photoSettings = AVCapturePhotoSettings.Create();
}
if (videoDeviceInput.Device.FlashAvailable)
{
photoSettings.FlashMode = AVCaptureFlashMode.Auto;
}
photoSettings.IsHighResolutionPhotoEnabled = true;
if (photoSettings.AvailablePreviewPhotoPixelFormatTypes.Count() > 0)
{
photoSettings.PreviewPhotoFormat = new NSDictionary <NSString, NSObject>(CoreVideo.CVPixelBuffer.PixelFormatTypeKey, photoSettings.AvailablePreviewPhotoPixelFormatTypes.First());
}
if (livePhotoMode == AVCamLivePhotoMode.On && photoOutput.IsLivePhotoCaptureSupported)
{
// Live Photo capture is not supported in movie mode.
var livePhotoMovieFileName = Guid.NewGuid().ToString();
var livePhotoMovieFilePath = NSFileManager.DefaultManager.GetTemporaryDirectory().Append($"{livePhotoMovieFileName}.mov", false);
photoSettings.LivePhotoMovieFileUrl = livePhotoMovieFilePath;
}
if (depthDataDeliveryMode == AVCamDepthDataDeliveryMode.On && photoOutput.IsDepthDataDeliverySupported())
{
photoSettings.IsDepthDataDeliveryEnabled(true);
}
else
{
photoSettings.IsDepthDataDeliveryEnabled(false);
}
// Use a separate object for the photo capture delegate to isolate each capture life cycle.
var photoCaptureDelegate = new AVCamPhotoCaptureDelegate(photoSettings, () =>
{
DispatchQueue.MainQueue.DispatchAsync(() =>
{
VideoPreviewLayer.Opacity = 0.0f;
UIView.Animate(0.25, () =>
{
VideoPreviewLayer.Opacity = 1.0f;
});
});
}, (bool capturing) =>
{
/*
* Because Live Photo captures can overlap, we need to keep track of the
* number of in progress Live Photo captures to ensure that the
* Live Photo label stays visible during these captures.
*/
sessionQueue.DispatchAsync(() =>
{
if (capturing)
{
inProgressLivePhotoCapturesCount++;
}
else
{
inProgressLivePhotoCapturesCount--;
}
var lInProgressLivePhotoCapturesCount = inProgressLivePhotoCapturesCount;
//DispatchQueue.MainQueue.DispatchAsync(() =>
//{
// if (lInProgressLivePhotoCapturesCount > 0)
// {
// CapturingLivePhotoLabel.Hidden = false;
// }
// else if (lInProgressLivePhotoCapturesCount == 0)
// {
// CapturingLivePhotoLabel.Hidden = true;
// }
// else
// {
// Console.WriteLine(@"Error: In progress live photo capture count is less than 0");
// }
//});
});
}, (AVCamPhotoCaptureDelegate lPhotoCaptureDelegate) =>
{
// When the capture is complete, remove a reference to the photo capture delegate so it can be deallocated.
sessionQueue.DispatchAsync(() =>
{
inProgressPhotoCaptureDelegates[lPhotoCaptureDelegate.RequestedPhotoSettings.UniqueID] = null;
});
});
/*
* The Photo Output keeps a weak reference to the photo capture delegate so
* we store it in an array to maintain a strong reference to this object
* until the capture is completed.
*/
inProgressPhotoCaptureDelegates[photoCaptureDelegate.RequestedPhotoSettings.UniqueID] = photoCaptureDelegate;
photoOutput.CapturePhoto(photoSettings, photoCaptureDelegate);
});
}
void CapturePhoto()
{
// Retrieve the video preview layer's video orientation on the main queue before
// entering the session queue. We do this to ensure UI elements are accessed on
// the main thread and session configuration is done on the session queue.
var videoPreviewLayerOrientation = PreviewView.VideoPreviewLayer.Connection.VideoOrientation;
sessionQueue.DispatchAsync(() => {
// Update the photo output's connection to match the video orientation of the video preview layer.
var photoOutputConnection = photoOutput.ConnectionFromMediaType(AVMediaType.Video);
if (photoOutputConnection != null)
{
photoOutputConnection.VideoOrientation = videoPreviewLayerOrientation;
}
// Capture a JPEG photo with flash set to auto and high resolution photo enabled.
var photoSettings = AVCapturePhotoSettings.Create();
photoSettings.FlashMode = (videoDeviceInput.Device.HasFlash) ? AVCaptureFlashMode.Auto : AVCaptureFlashMode.Off;
photoSettings.IsHighResolutionPhotoEnabled = true;
// TODO: request strong typed API
if (photoSettings.AvailablePreviewPhotoPixelFormatTypes.Length > 0)
{
photoSettings.PreviewPhotoFormat = new NSDictionary <NSString, NSObject>(CVPixelBuffer.PixelFormatTypeKey, photoOutput.AvailablePhotoPixelFormatTypes[0]);
}
// Live Photo capture is not supported in movie mode.
if (livePhotoMode == LivePhotoMode.On && photoOutput.IsLivePhotoCaptureSupported)
{
var livePhotoMovieFileName = new NSUuid().AsString();
var livePhotoMovieFilePath = Path.Combine(Path.GetTempPath(), Path.ChangeExtension(livePhotoMovieFileName, "mov"));
photoSettings.LivePhotoMovieFileUrl = NSUrl.FromFilename(livePhotoMovieFilePath);
}
// Use a separate object for the photo capture delegate to isolate each capture life cycle.
var photoCaptureDelegate = new PhotoCaptureDelegate(photoSettings, () => DispatchQueue.MainQueue.DispatchAsync(() => {
PreviewView.VideoPreviewLayer.Opacity = 0;
UIView.Animate(0.25, () => PreviewView.VideoPreviewLayer.Opacity = 1);
}), capturing => {
// Because Live Photo captures can overlap, we need to keep track of the
// number of in progress Live Photo captures to ensure that the
// Live Photo label stays visible during these captures.
sessionQueue.DispatchAsync(() => {
if (capturing)
{
inProgressLivePhotoCapturesCount += 1;
}
else
{
inProgressLivePhotoCapturesCount -= 1;
}
var count = inProgressLivePhotoCapturesCount;
DispatchQueue.MainQueue.DispatchAsync(() => {
if (count > 0)
{
CapturingLivePhotoLabel.Hidden = false;
}
else if (count == 0)
{
CapturingLivePhotoLabel.Hidden = true;
}
else
{
Console.WriteLine("Error: In progress live photo capture count is less than 0");
}
});
});
}, photoDelegate => {
// When the capture is complete, remove a reference to the photo capture delegate so it can be deallocated.
sessionQueue.DispatchAsync(() => inProgressPhotoCaptureDelegates.Remove(photoDelegate.RequestedPhotoSettings.UniqueID));
});
// The Photo Output keeps a weak reference to the photo capture delegate so
// we store it in an array to maintain a strong reference to this object
// until the capture is completed.
inProgressPhotoCaptureDelegates[photoCaptureDelegate.RequestedPhotoSettings.UniqueID] = photoCaptureDelegate;
photoOutput.CapturePhoto(photoSettings, photoCaptureDelegate);
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------
partial void CapturePhotoButton_TouchUpInside(UIButton sender)
{
var videoPreviewLayerVideoOrientation = PreviewView.VideoPreviewLayer.Connection.VideoOrientation;
// Update the photo output's connection to match the video orientation of the video preview layer.
var photoOutputConnection = photoOutput.ConnectionFromMediaType(AVMediaType.Video);
photoOutputConnection.VideoOrientation = videoPreviewLayerVideoOrientation;
AVCapturePhotoSettings photoSettings;
// Capture HEIF photo when supported, with flash set to auto and high resolution photo enabled.
if (photoOutput.AvailablePhotoCodecTypes.Where(codec => codec == AVVideo2.CodecHEVC).Any())
{
photoSettings = AVCapturePhotoSettings.FromFormat(new NSDictionary <NSString, NSObject> (AVVideo.CodecKey, AVVideo2.CodecHEVC));
}
else
{
photoSettings = AVCapturePhotoSettings.Create();
}
if (videoDeviceInput.Device.FlashAvailable)
{
photoSettings.FlashMode = AVCaptureFlashMode.Auto;
}
photoSettings.IsHighResolutionPhotoEnabled = true;
if (photoSettings.AvailablePreviewPhotoPixelFormatTypes.Count() > 0)
{
photoSettings.PreviewPhotoFormat = new NSDictionary <NSString, NSObject> (CoreVideo.CVPixelBuffer.PixelFormatTypeKey, photoSettings.AvailablePreviewPhotoPixelFormatTypes.First());
}
photoSettings.IsDepthDataDeliveryEnabled(false);
// Use a separate object for the photo capture delegate to isolate each capture life cycle.
var photoCaptureDelegate = new AVCamPhotoCaptureDelegate(photoSettings, () => {
PreviewView.VideoPreviewLayer.Opacity = 0.0f;
UIView.Animate(0.25, () => {
PreviewView.VideoPreviewLayer.Opacity = 1.0f;
});
}, (bool capturing ) => {
/*
* Because Live Photo captures can overlap, we need to keep track of the
* number of in progress Live Photo captures to ensure that the
* Live Photo label stays visible during these captures.
*/
/* if (capturing)
* {
* inProgressLivePhotoCapturesCount++;
* }
* else
* {
* inProgressLivePhotoCapturesCount--;
* }
*
* var lInProgressLivePhotoCapturesCount = inProgressLivePhotoCapturesCount;
*
* if (lInProgressLivePhotoCapturesCount > 0)
* {
* CapturingLivePhotoLabel.Hidden = false;
* }
* else if (lInProgressLivePhotoCapturesCount == 0)
* {
* CapturingLivePhotoLabel.Hidden = true;
* }
* else
* {
* Console.WriteLine (@"Error: In progress live photo capture count is less than 0");
* }*/
}, (AVCamPhotoCaptureDelegate lPhotoCaptureDelegate ) => {
// When the capture is complete, remove a reference to the photo capture delegate so it can be deallocated.
inProgressPhotoCaptureDelegates[lPhotoCaptureDelegate.RequestedPhotoSettings.UniqueID] = null;
});
/*
* The Photo Output keeps a weak reference to the photo capture delegate so
* we store it in an array to maintain a strong reference to this object
* until the capture is completed.
*/
inProgressPhotoCaptureDelegates[photoCaptureDelegate.RequestedPhotoSettings.UniqueID] = photoCaptureDelegate;
photoOutput.CapturePhoto(photoSettings, photoCaptureDelegate);
}