#pragma warning restore CS4014
private void SetupLiveCameraStream()
{
captureSession = new AVCaptureSession();
var viewLayer = CameraFeedView.Layer;
videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = CameraFeedView.Frame,
VideoGravity = AVLayerVideoGravity.ResizeAspectFill
};
CameraFeedView.Layer.AddSublayer(videoPreviewLayer);
AVCaptureDevice captureDevice = AVCaptureDevice.GetDefaultDevice(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
captureSession.AddInput(captureDeviceInput);
if (isMovie)
{
// Add audio
var audioDevice = AVCaptureDevice.GetDefaultDevice(AVMediaTypes.Audio);
var audioDeviceInput = AVCaptureDeviceInput.FromDevice(audioDevice, out NSError audioErr);
if (audioErr != null)
{
Console.WriteLine("Couldn't create audio device input: " + audioErr.LocalizedDescription);
}
if (captureSession.CanAddInput(audioDeviceInput))
{
captureSession.AddInput(audioDeviceInput);
}
else
{
Console.WriteLine("Couldn't add audio input to session");
}
movieOutput = new AVCaptureMovieFileOutput();
captureSession.AddOutput(movieOutput);
captureSession.SessionPreset = AVCaptureSession.Preset1280x720;
var connection = movieOutput.ConnectionFromMediaType(AVMediaType.Video);
if (connection != null && connection.SupportsVideoStabilization)
{
connection.PreferredVideoStabilizationMode = AVCaptureVideoStabilizationMode.Auto;
}
captureSession.CommitConfiguration();
}
else
{
stillImageOutput = new AVCapturePhotoOutput();
stillImageOutput.IsHighResolutionCaptureEnabled = true;
stillImageOutput.IsLivePhotoCaptureEnabled = false;
captureSession.AddOutput(stillImageOutput);
captureSession.CommitConfiguration();
}
ShutterButton.Hidden = false;
captureSession.StartRunning();
}
public static CaptureSession Create(SelfView parent)
{
// create a device input and attach it to the session
var captureDevice = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video).FirstOrDefault(d => d.Position == AVCaptureDevicePosition.Front);
if (captureDevice == null)
{
return(null);
}
var input = AVCaptureDeviceInput.FromDevice(captureDevice);
if (input == null)
{
return(null);
}
var output = new AVCaptureMetadataOutput();
var cs = new CaptureSession(parent, input, output);
// This must be set after the output is added to the sesssion
output.MetadataObjectTypes = AVMetadataObjectType.Face;
return(cs);
}
public async void SetupLiveCameraStream()
{
captureSession = new AVCaptureSession();
var viewLayer = liveCameraStream.Layer;
var videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = liveCameraStream.Bounds
};
liveCameraStream.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
var dictionary = new NSMutableDictionary();
dictionary[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG);
stillImageOutput = new AVCaptureStillImageOutput()
{
OutputSettings = new NSDictionary()
};
captureSession.AddOutput(stillImageOutput);
captureSession.AddInput(captureDeviceInput);
captureSession.StartRunning();
await SkinSelfie.Pages.CameraPage.ShowTip();
}
void Initialize()
{
CaptureSession = new AVCaptureSession();
previewLayer = new AVCaptureVideoPreviewLayer(CaptureSession);
previewLayer.Frame = Bounds;
previewLayer.VideoGravity = AVLayerVideoGravity.ResizeAspectFill;
previewLayer.Orientation = AVCaptureVideoOrientation.Portrait;
var videoDevices = AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video);
var cameraPosition = (CameraOption == CameraOptions.Front) ? AVCaptureDevicePosition.Front : AVCaptureDevicePosition.Back;
var device = videoDevices.FirstOrDefault(d => d.Position == cameraPosition);
if (device == null)
{
return;
}
ConfigureCameraForDevice(device);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(device);
CaptureSession.AddInput(captureDeviceInput);
Layer.AddSublayer(previewLayer);
output = new AVCaptureStillImageOutput {
OutputSettings = new NSDictionary(AVVideo.CodecKey, AVVideo.CodecJPEG)
};
CaptureSession.AddOutput(output);
}
bool SetupCaptureSession()
{
// configure the capture session for low resolution, change this if your code
// can cope with more data or volume
session = new AVCaptureSession()
{
SessionPreset = AVCaptureSession.PresetMedium
};
// create a device input and attach it to the session
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
if (captureDevice == null)
{
Console.WriteLine("No captureDevice - this won't work on the simulator, try a physical device");
return(false);
}
//Configure for 15 FPS. Note use of LockForConigfuration()/UnlockForConfiguration()
NSError error = null;
captureDevice.LockForConfiguration(out error);
if (error != null)
{
Console.WriteLine(error);
captureDevice.UnlockForConfiguration();
return(false);
}
if (UIDevice.CurrentDevice.CheckSystemVersion(7, 0))
{
captureDevice.ActiveVideoMinFrameDuration = new CMTime(1, 15);
}
captureDevice.UnlockForConfiguration();
var input = AVCaptureDeviceInput.FromDevice(captureDevice);
if (input == null)
{
Console.WriteLine("No input - this won't work on the simulator, try a physical device");
return(false);
}
session.AddInput(input);
// create a VideoDataOutput and add it to the sesion
var output = new AVCaptureVideoDataOutput()
{
WeakVideoSettings = new CVPixelBufferAttributes()
{
PixelFormatType = CVPixelFormatType.CV32BGRA
}.Dictionary,
};
// configure the output
queue = new CoreFoundation.DispatchQueue("myQueue");
outputRecorder = new OutputRecorder();
output.SetSampleBufferDelegate(outputRecorder, queue);
session.AddOutput(output);
session.StartRunning();
return(true);
}
public void ToggleFrontBackCamera()
{
var devicePosition = captureDeviceInput.Device.Position;
if (devicePosition == AVCaptureDevicePosition.Front)
{
devicePosition = AVCaptureDevicePosition.Back;
isSelfie = false;
}
else
{
devicePosition = AVCaptureDevicePosition.Front;
isSelfie = true;
}
var device = GetCameraForOrientation(devicePosition);
ConfigureCameraForDevice(device);
captureSession.BeginConfiguration();
captureSession.RemoveInput(captureDeviceInput);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(device);
captureSession.AddInput(captureDeviceInput);
captureSession.CommitConfiguration();
}
private void SetupLiveCameraStream()
{
captureSession = new AVCaptureSession();
videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = liveCameraStream.Bounds,
Orientation = GetCameraForOrientation()
};
liveCameraStream.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
var dictionary = new NSMutableDictionary();
dictionary[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG);
stillImageOutput = new AVCaptureStillImageOutput()
{
OutputSettings = new NSDictionary(),
};
captureSession.AddOutput(stillImageOutput);
captureSession.AddInput(captureDeviceInput);
stillImageOutput.ConnectionFromMediaType(AVMediaType.Video).VideoOrientation = GetCameraForOrientation();
captureSession.StartRunning();
}
private void PrepareCaptureSession()
{
try
{
session = new AVCaptureSession
{
SessionPreset = config.FrameQualityPreset,
};
captureDevice = config.Device;
deviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
deviceOutput = new AVCaptureVideoDataOutput();
deviceOutput.WeakVideoSettings = new CVPixelBufferAttributes {
PixelFormatType = config.PixelFormat
}.Dictionary;
deviceOutput.SetSampleBufferDelegateQueue(this, queue);
session.AddInput(deviceInput);
session.AddOutput(deviceOutput);
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
private void SetupLiveCameraStream()
{
captureSession = new AVCaptureSession();
captureSession.SessionPreset = AVCaptureSession.PresetMedium;
videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = new CGRect(0f, 0f, View.Bounds.Width, View.Bounds.Height),
Orientation = GetCameraForOrientation()
};
liveCameraStream.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
aVCaptureMovieFileOutput = new AVCaptureMovieFileOutput();
var audioDevice = AVCaptureDevice.GetDefaultDevice(AVMediaType.Audio);
var audioDeviceInput = AVCaptureDeviceInput.FromDevice(audioDevice);
captureSession.AddOutput(aVCaptureMovieFileOutput);
captureSession.AddInput(captureDeviceInput);
captureSession.AddInput(audioDeviceInput);
aVCaptureMovieFileOutput.ConnectionFromMediaType(AVMediaType.Video).VideoOrientation = GetCameraForOrientation();
captureSession.StartRunning();
}
void ChangeCamera(CameraViewController sender)
{
CameraButton.Enabled = false;
RecordButton.Enabled = false;
StillButton.Enabled = false;
SessionQueue.DispatchAsync(() => {
AVCaptureDevice currentVideoDevice = VideoDeviceInput.Device;
AVCaptureDevicePosition preferredPosition = AVCaptureDevicePosition.Unspecified;
AVCaptureDevicePosition currentPosition = currentVideoDevice.Position;
switch (currentPosition)
{
case AVCaptureDevicePosition.Unspecified:
case AVCaptureDevicePosition.Front:
preferredPosition = AVCaptureDevicePosition.Back;
break;
case AVCaptureDevicePosition.Back:
preferredPosition = AVCaptureDevicePosition.Front;
break;
}
AVCaptureDevice videoDevice = CreateDevice(AVMediaType.Video, preferredPosition);
AVCaptureDeviceInput videoDeviceInput = AVCaptureDeviceInput.FromDevice(videoDevice);
Session.BeginConfiguration();
// Remove the existing device input first, since using the front and back camera simultaneously is not supported.
Session.RemoveInput(VideoDeviceInput);
if (Session.CanAddInput(videoDeviceInput))
{
subjectSubscriber.Dispose();
SetFlashModeForDevice(AVCaptureFlashMode.Auto, videoDevice);
subjectSubscriber = NSNotificationCenter.DefaultCenter.AddObserver(AVCaptureDevice.SubjectAreaDidChangeNotification, SubjectAreaDidChange, videoDevice);
Session.AddInput(videoDeviceInput);
VideoDeviceInput = videoDeviceInput;
}
else
{
Session.AddInput(VideoDeviceInput);
}
AVCaptureConnection connection = MovieFileOutput.ConnectionFromMediaType(AVMediaType.Video);
if (connection.SupportsVideoStabilization)
{
connection.PreferredVideoStabilizationMode = AVCaptureVideoStabilizationMode.Auto;
}
Session.CommitConfiguration();
DispatchQueue.MainQueue.DispatchAsync(() => {
CameraButton.Enabled = true;
RecordButton.Enabled = true;
StillButton.Enabled = true;
});
});
}
private void SetupLiveCameraStream()
{
captureSession = new AVCaptureSession();
var videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = liveCameraStream.Bounds
};
liveCameraStream.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
stillImageOutput = new AVCaptureStillImageOutput
{
OutputSettings = new NSDictionary()
};
captureSession.AddOutput(stillImageOutput);
captureSession.AddInput(captureDeviceInput);
captureSession.StartRunning();
}
void SetupLiveCameraStream()
{
_captureSession = new AVCaptureSession();
var viewLayer = _liveCameraStream.Layer;
_videoPreviewLayer = new AVCaptureVideoPreviewLayer(_captureSession)
{
Frame = _liveCameraStream.Bounds
};
_liveCameraStream.AddObserver("bounds", NSKeyValueObservingOptions.New, ObservedBoundsChange);
_liveCameraStream.Layer.AddSublayer(_videoPreviewLayer);
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
_captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
var dictionary = new NSMutableDictionary();
dictionary[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG);
_stillImageOutput = new AVCaptureStillImageOutput {
OutputSettings = new NSDictionary()
};
_captureSession.AddOutput(_stillImageOutput);
_captureSession.AddInput(_captureDeviceInput);
_captureSession.StartRunning();
}
void SetupCaptureDevice()
{
captureDevice = AVCaptureDevice.GetDefaultDevice(AVMediaTypes.Video);
if (captureDevice == null)
{
Console.WriteLine("Error: no video devices available");
return;
}
videoDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
if (videoDeviceInput == null)
{
Console.WriteLine("Error: could not create AVCaptureDeviceInput");
return;
}
if (captureSession.CanAddInput(videoDeviceInput))
{
captureSession.AddInput(videoDeviceInput);
}
previewLayer = AVCaptureVideoPreviewLayer.FromSession(captureSession);
previewLayer.VideoGravity = AVLayerVideoGravity.ResizeAspect;
previewLayer.Connection.VideoOrientation = AVCaptureVideoOrientation.Portrait;
}
private bool InitScanner(BarcodeScanner.BarcodeFormat barcodeType)
{
device = AVCaptureDevice.GetDefaultDevice(AVMediaType.Video);
if (device == null)
{
return(false);
}
input = AVCaptureDeviceInput.FromDevice(device);
if (input.Device.IsFocusModeSupported(AVCaptureFocusMode.ContinuousAutoFocus))
{
input.Device.LockForConfiguration(out NSError err);
input.Device.FocusMode = AVCaptureFocusMode.ContinuousAutoFocus;
input.Device.UnlockForConfiguration();
}
if (input == null)
{
return(false);
}
output = new AVCaptureMetadataOutput();
output.SetDelegate(this, DispatchQueue.MainQueue);
session = new AVCaptureSession();
session.AddInput(input);
session.AddOutput(output);
output.MetadataObjectTypes = GetBarcodeFormat(barcodeType);
captureVideoPreviewLayer = AVCaptureVideoPreviewLayer.FromSession(session);
captureVideoPreviewLayer.Frame = CGRect.Empty;
captureVideoPreviewLayer.VideoGravity = AVLayerVideoGravity.ResizeAspectFill;
captureVideoPreviewLayer.Connection.VideoOrientation = GetDeviceOrientation();
return(true);
}
public void SetupLiveCameraStream(object cameraView)
{
_cameraView = (UIView)cameraView;
captureSession = new AVCaptureSession();
var videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = _cameraView.Frame,
VideoGravity = AVLayerVideoGravity.ResizeAspectFill
};
_cameraView.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.GetDefaultDevice(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
captureSession.AddInput(captureDeviceInput);
var dictionary = new NSMutableDictionary();
dictionary[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG);
stillImageOutput = new AVCaptureStillImageOutput()
{
OutputSettings = new NSDictionary()
};
captureSession.AddOutput(stillImageOutput);
captureSession.StartRunning();
}
void ShowCameraPreview()
{
var captureSession = new AVCaptureSession();
var viewLayer = liveCameraStream.Layer;
videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = this.View.Frame
};
liveCameraStream.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
captureSession.AddInput(captureDeviceInput);
var dictionary = new NSMutableDictionary();
dictionary[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG);
stillImageOutput = new AVCaptureStillImageOutput()
{
OutputSettings = new NSDictionary()
};
captureSession.AddOutput(stillImageOutput);
captureSession.StartRunning();
captureButton.Hidden = false;
cancelButton.Hidden = false;
}
public void SetupLiveCameraStream()
{
CaptureSession = new AVCaptureSession();
var viewLayer = this.Layer;
videoPreviewLayer = new AVCaptureVideoPreviewLayer(CaptureSession)
{
Frame = this.Frame
};
this.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
CaptureSession.AddInput(captureDeviceInput);
var dictionary = new NSMutableDictionary();
dictionary[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG);
stillImageOutput = new AVCaptureStillImageOutput()
{
OutputSettings = new NSDictionary()
};
CaptureSession.AddOutput(stillImageOutput);
CaptureSession.StartRunning();
}
private void InitializeSession()
{
if (this.session != null)
{
throw new InvalidOperationException("A session is currently active.");
}
this.session = new AVCaptureSession();
this.session.BeginConfiguration();
this.session.SessionPreset = AVCaptureSession.PresetPhoto;
NSError error;
AVCaptureDeviceInput deviceInput = AVCaptureDeviceInput.FromDevice(this.device, out error);
if (deviceInput == null)
{
throw new NSErrorException(error);
}
this.session.AddInput(deviceInput);
this.InitializeOutput();
this.session.AddOutput(this.output);
session.CommitConfiguration();
}
void SwitchCameraType()
{
var devicePosition = captureDeviceInput.Device.Position;
if (devicePosition == AVCaptureDevicePosition.Front)
{
devicePosition = AVCaptureDevicePosition.Back;
}
else
{
devicePosition = AVCaptureDevicePosition.Front;
}
if ((Element.CameraType == CameraType.Front && devicePosition == AVCaptureDevicePosition.Front) || (Element.CameraType == CameraType.Rear && devicePosition == AVCaptureDevicePosition.Back))
{
return;
}
var device = GetCameraForOrientation(devicePosition);
ConfigureCameraForDevice(device);
captureSession.BeginConfiguration();
captureSession.RemoveInput(captureDeviceInput);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(device);
captureSession.AddInput(captureDeviceInput);
captureSession.CommitConfiguration();
}
public void Start()
{
captureSession = new AVCaptureSession();
previewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
VideoGravity = AVLayerVideoGravity.ResizeAspectFill,
};
try
{
var captureDevice = AVCaptureDevice.GetDefaultDevice(AVMediaTypes.Video);
var input = AVCaptureDeviceInput.FromDevice(captureDevice);
var output = new AVCaptureMetadataOutput();
var queue = new DispatchQueue("qrQueue");
captureSession.AddInput(input);
captureSession.AddOutput(output);
output.SetDelegate(this, queue);
output.MetadataObjectTypes = AVMetadataObjectType.QRCode;
Layer.AddSublayer(previewLayer);
captureSession.StartRunning();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void SetupLiveCameraStream()
{
captureSession = new AVCaptureSession();
videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = liveCameraStream.Bounds
};
liveCameraStream.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.GetDefaultDevice(AVMediaType.Video);
device = captureDevice;
maxExposure = device.ActiveFormat.MaxISO;
minExposure = device.ActiveFormat.MinISO;
maxDuration = device.ActiveFormat.MaxExposureDuration.Seconds;
minDuration = device.ActiveFormat.MinExposureDuration.Seconds;
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
var dictionary = new NSMutableDictionary();
dictionary[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG);
stillImageOutput = new AVCaptureStillImageOutput()
{
OutputSettings = new NSDictionary()
};
captureSession.AddOutput(stillImageOutput);
captureSession.AddInput(captureDeviceInput);
captureSession.StartRunning();
}
public void ToggleFrontBackCamera()
{
var devicePosition = captureDeviceInput.Device.Position;
if (devicePosition == AVCaptureDevicePosition.Front)
{
devicePosition = AVCaptureDevicePosition.Back;
toggleCameraButton.SetBackgroundImage(frontCameraIcon, UIControlState.Normal);
}
else
{
devicePosition = AVCaptureDevicePosition.Front;
toggleCameraButton.SetBackgroundImage(rearCameraIcon, UIControlState.Normal);
}
var device = GetCameraForOrientation(devicePosition);
ConfigureCameraForDevice(device);
captureSession.BeginConfiguration();
captureSession.RemoveInput(captureDeviceInput);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(device);
captureSession.AddInput(captureDeviceInput);
captureSession.CommitConfiguration();
}
private void TryStart()
{
if (contentLayer != null)
{
session = new AVCaptureSession();
var camera = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
var input = AVCaptureDeviceInput.FromDevice(camera);
session.AddInput(input);
// create a VideoDataOutput and add it to the sesion
var settings = new CVPixelBufferAttributes
{
PixelFormatType = CVPixelFormatType.CV32BGRA
};
using (var output = new AVCaptureVideoDataOutput {
WeakVideoSettings = settings.Dictionary
})
{
queue = new DispatchQueue("s4mQueue");
outputRecorder = new OutputRecorder();
output.SetSampleBufferDelegate(outputRecorder, queue);
session.AddOutput(output);
}
this.contentLayer.Session = session;
session.StartRunning();
}
}
private void SetupCamera()
{
try
{
if (_captureSession == null)
{
_captureSession = new AVCaptureSession
{
SessionPreset = AVCaptureSession.PresetPhoto
};
}
SetPreviewSizing();
SetPreviewOrientation();
if (_photoOutput == null)
{
_device = AVCaptureDevice.GetDefaultDevice(AVMediaTypes.Video);
TurnOffFlashAndSetContinuousAutoMode(_device);
_photoOutput = new AVCapturePhotoOutput
{
IsHighResolutionCaptureEnabled = true
};
_captureSession.AddOutput(_photoOutput);
_captureSession.AddInput(AVCaptureDeviceInput.FromDevice(_device));
}
}
catch (Exception e)
{
_cameraModule.ErrorMessage = e.ToString();
}
}
public void SetupLiveCameraStream()
{
captureSession = new AVCaptureSession();
//.PresetPhoto for camera image feed
captureSession.SessionPreset = AVCaptureSession.PresetPhoto;
var viewLayer = liveCameraStream.Layer;
videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = this.View.Frame,
};
liveCameraStream.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.GetDefaultDevice(AVMediaType.Video);
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
captureSession.AddInput(captureDeviceInput);
var dictionary = new NSMutableDictionary
{
[AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG)
};
stillImageOutput = new AVCaptureStillImageOutput
{
OutputSettings = new NSDictionary()
};
captureSession.AddOutput(stillImageOutput);
captureSession.StartRunning();
}
AVCaptureDeviceInput pickCamera()
{
AVCaptureDevicePosition desiredPosition = AVCaptureDevicePosition.Back;
bool hadError = false;
foreach (var device in AVCaptureDevice.DevicesWithMediaType(AVMediaType.Video))
{
if (device.Position == desiredPosition)
{
NSError error = null;
AVCaptureDeviceInput input = AVCaptureDeviceInput.FromDevice(device, out error);
if (error != null)
{
hadError = true;
displayErrorOnMainQueue(error, "Could not initialize for AVMediaTypeVideo");
}
else if (session.CanAddInput(input))
{
return(input);
}
}
}
if (!hadError)
{
displayErrorOnMainQueue(null, "No camera found for requested orientation");
}
return(null);
}
private bool initScanner()
{
device = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
if (device == null)
{
this.Debug("AVCaptureDevice is null");
return(false);
}
input = AVCaptureDeviceInput.FromDevice(device);
if (input == null)
{
this.Debug("AVCaptureDeviceInput is null");
return(false);
}
output = new AVCaptureMetadataOutput();
output.SetDelegate(this, DispatchQueue.MainQueue);
session = new AVCaptureSession();
session.AddInput(input);
session.AddOutput(output);
output.MetadataObjectTypes = configuration.Barcodes.ConvertToIOS();
captureVideoPreviewLayer = AVCaptureVideoPreviewLayer.FromSession(session);
captureVideoPreviewLayer.Frame = CGRect.Empty;
captureVideoPreviewLayer.VideoGravity = AVLayerVideoGravity.ResizeAspectFill;
captureVideoPreviewLayer.Connection.VideoOrientation = getDeviceOrientation();
return(true);
}
void UpdateCameraOption()
{
var devices = AVCaptureDeviceDiscoverySession.Create(
new AVCaptureDeviceType[] { AVCaptureDeviceType.BuiltInWideAngleCamera, AVCaptureDeviceType.BuiltInDualCamera },
AVMediaType.Video,
AVCaptureDevicePosition.Unspecified
);
var cameraPosition = (cameraOptions == CameraOptions.Front) ? AVCaptureDevicePosition.Front : AVCaptureDevicePosition.Back;
var device = devices.Devices.FirstOrDefault(d => d.Position == cameraPosition);
if (device != null)
{
var lVideoDeviceInput = AVCaptureDeviceInput.FromDevice(device);
captureSession.BeginConfiguration();
// Remove the existing device input first, since using the front and back camera simultaneously is not supported.
captureSession.RemoveInput(videoDeviceInput);
if (captureSession.CanAddInput(lVideoDeviceInput))
{
captureSession.AddInput(lVideoDeviceInput);
videoDeviceInput = lVideoDeviceInput;
}
else
{
captureSession.AddInput(videoDeviceInput);
}
captureSession.CommitConfiguration();
}
}
public void SetupLiveCameraStream()
{
captureSession = new AVCaptureSession();
//var viewLayer = liveCameraStream.Layer;
var videoPreviewLayer = new AVCaptureVideoPreviewLayer(captureSession)
{
Frame = liveCameraStream.Bounds
};
liveCameraStream.Layer.AddSublayer(videoPreviewLayer);
var captureDevice = AVCaptureDevice.GetDefaultDevice(AVMediaTypes.Video);
// HACK: Dunno why this is returning null????
if (captureDevice is null)
{
return;
}
ConfigureCameraForDevice(captureDevice);
captureDeviceInput = AVCaptureDeviceInput.FromDevice(captureDevice);
//var dictionary = new NSMutableDictionary
//{
// [AVVideo.CodecKey] = new NSNumber((int)AVVideoCodec.JPEG)
//};
stillImageOutput = new AVCaptureStillImageOutput()
{
OutputSettings = new NSDictionary()
};
captureSession.AddOutput(stillImageOutput);
captureSession.AddInput(captureDeviceInput);
captureSession.StartRunning();
}
bool SetupCaptureSession()
{
// configure the capture session for low resolution, change this if your code
// can cope with more data or volume
session = new AVCaptureSession()
{
SessionPreset = AVCaptureSession.PresetMedium
};
// create a device input and attach it to the session
var captureDevice = AVCaptureDevice.DefaultDeviceWithMediaType(AVMediaType.Video);
if (captureDevice == null)
{
Image <Bgr, Byte> img = new Image <Bgr, byte> (512, 512, new Bgr(255, 255, 255));
CvInvoke.PutText(
img,
"Capture device not found.",
new Point(10, 200),
FontFace.HersheyComplex,
1,
new MCvScalar(),
2);
ImageView.Image = img.ToUIImage();
return(false);
}
var input = AVCaptureDeviceInput.FromDevice(captureDevice);
if (input == null)
{
Console.WriteLine("No input device");
return(false);
}
session.AddInput(input);
// create a VideoDataOutput and add it to the sesion
AVVideoSettingsUncompressed settingUncomp = new AVVideoSettingsUncompressed();
settingUncomp.PixelFormatType = CVPixelFormatType.CV32BGRA;
var output = new AVCaptureVideoDataOutput()
{
UncompressedVideoSetting = settingUncomp,
// If you want to cap the frame rate at a given speed, in this sample: 15 frames per second
//MinFrameDuration = new CMTime (1, 15)
};
// configure the output
queue = new DispatchQueue("myQueue");
outputRecorder = new OutputRecorder(ImageView);
output.SetSampleBufferDelegateQueue(outputRecorder, queue);
session.AddOutput(output);
session.StartRunning();
return(true);
}
