public void ConfigureCameraForDevice(AVCaptureDevice device)
{
var error = new NSError();
var photoSettings = AVCapturePhotoSettings.Create();
photoSettings.FlashMode = AVCaptureFlashMode.Auto;
photoSettings.IsHighResolutionPhotoEnabled = true;
if (device.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
{
device.LockForConfiguration(out error);
device.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
device.UnlockForConfiguration();
}
else if (device.IsExposureModeSupported(AVCaptureExposureMode.ContinuousAutoExposure))
{
device.LockForConfiguration(out error);
device.ExposureMode = AVCaptureExposureMode.ContinuousAutoExposure;
device.UnlockForConfiguration();
}
else if (device.IsWhiteBalanceModeSupported(AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance))
{
device.LockForConfiguration(out error);
device.WhiteBalanceMode = AVCaptureWhiteBalanceMode.ContinuousAutoWhiteBalance;
device.UnlockForConfiguration();
}
}
protected void TakePicture()
{
var session = _cameraPreview.CaptureSession;
var output = session.Outputs[0] as AVCapturePhotoOutput;
//output.IsHighResolutionCaptureEnabled = true;
var photoSettings = AVCapturePhotoSettings.Create();
photoSettings.IsAutoStillImageStabilizationEnabled = true;
//photoSettings.IsHighResolutionPhotoEnabled = true;
var flashModeAuto = output?.SupportedFlashModes.Contains(_flashModeAutoFlash) ?? false;
if (flashModeAuto == true)
{
photoSettings.FlashMode = AVCaptureFlashMode.Auto;
}
if (photoSettings.AvailablePreviewPhotoPixelFormatTypes.Length > 0)
{
photoSettings.PreviewPhotoFormat = new NSDictionary <NSString, NSObject>(CVPixelBuffer.PixelFormatTypeKey, output.AvailablePhotoPixelFormatTypes[0]);
}
var photoCaptureDelegate = new PhotoCaptureDelegate();
photoCaptureDelegate.PictureTaken += OnPictureTaken;
output.CapturePhoto(photoSettings, photoCaptureDelegate);
}
private void CapturePhoto()
{
var photoSettings = AVCapturePhotoSettings.Create();
photoSettings.IsHighResolutionPhotoEnabled = true;
_photoOutput.CapturePhoto(photoSettings, 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);
});
}
private async void CapturePhoto()
{
try
{
if (_is10OrHigher)
{
var photoSettings = AVCapturePhotoSettings.Create();
photoSettings.IsHighResolutionPhotoEnabled = true;
_photoOutput.CapturePhoto(photoSettings, this);
}
else
{
var videoConnection = _stillImageOutput.ConnectionFromMediaType(AVMediaType.Video);
var sampleBuffer = await _stillImageOutput.CaptureStillImageTaskAsync(videoConnection);
if (_cameraModule.BluetoothOperator.IsPrimary ||
_cameraModule.BluetoothOperator.PairStatus != PairStatus.Connected)
{
_cameraModule.CaptureSuccess = !_cameraModule.CaptureSuccess;
}
if (!(_cameraModule.BluetoothOperator.PairStatus == PairStatus.Connected &&
!_cameraModule.BluetoothOperator.IsPrimary))
{
LockPictureSpecificSettingsIfApplicable();
}
var jpegImageAsNsData = AVCaptureStillImageOutput.JpegStillToNSData(sampleBuffer);
using (var image = UIImage.LoadFromData(jpegImageAsNsData))
using (var cgImage = image.CGImage)
using (var rotatedImage = UIImage.FromImage(cgImage, 1, GetOrientationForCorrection()))
{
var imageBytes = rotatedImage.AsJPEG().ToArray();
if (_cameraModule.BluetoothOperator.PairStatus == PairStatus.Connected &&
!_cameraModule.BluetoothOperator.IsPrimary)
{
_cameraModule.BluetoothOperator.SendCapture(imageBytes);
}
else
{
_cameraModule.CapturedImage = imageBytes;
}
}
}
}
catch (Exception e)
{
_cameraModule.ErrorMessage = e.ToString();
}
}
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);
}
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);
}
}
void HandleButtonClick()
{
ToggleBusy(true);
if (OCRButton.TitleLabel.Text == "Take Picture")
{
using (var settings = AVCapturePhotoSettings.Create())
{
ImageOutput.CapturePhoto(settings, Camera);
}
OCRButton.SetTitle("Retake Picture", UIControlState.Normal);
}
else
{
PictureView.Image = null;
Capture = null;
OCRButton.SetTitle("Take Picture", UIControlState.Normal);
ToggleBusy(false);
}
}
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);
}