Example #1
0
        public static async Task <ContinuousAutoFocus> StartAsync(FocusControl control)
        {
            var autoFocus = new ContinuousAutoFocus(control);

            AutoFocusRange range;

            if (control.SupportedFocusRanges.Contains(AutoFocusRange.FullRange))
            {
                range = AutoFocusRange.FullRange;
            }
            else if (control.SupportedFocusRanges.Contains(AutoFocusRange.Normal))
            {
                range = AutoFocusRange.Normal;
            }
            else
            {
                // Auto-focus disabled
                return(autoFocus);
            }

            FocusMode mode;

            if (control.SupportedFocusModes.Contains(FocusMode.Continuous))
            {
                mode = FocusMode.Continuous;
            }
            else if (control.SupportedFocusModes.Contains(FocusMode.Single))
            {
                mode = FocusMode.Single;
            }
            else
            {
                // Auto-focus disabled
                return(autoFocus);
            }

            if (mode == FocusMode.Continuous)
            {
                // True continuous auto-focus
                var settings = new FocusSettings()
                {
                    AutoFocusRange        = range,
                    Mode                  = mode,
                    WaitForFocus          = false,
                    DisableDriverFallback = false
                };
                control.Configure(settings);
                await control.FocusAsync();
            }
            else
            {
                // Simulated continuous auto-focus
                var settings = new FocusSettings()
                {
                    AutoFocusRange        = range,
                    Mode                  = mode,
                    WaitForFocus          = true,
                    DisableDriverFallback = false
                };
                control.Configure(settings);

                var ignore = Task.Run(async() => { await autoFocus.DriveAutoFocusAsync(); });
            }

            return(autoFocus);
        }
        // Must be called on the UI thread
        private async Task DisposeCaptureAsync()
        {
            Preview.Source = null;

            if (autoFocus != null)
            {
                autoFocus.Dispose();
                autoFocus = null;
            }

            MediaCapture mediaCapture;
            lock (this)
            {
                mediaCapture = this.mediaCapture;
                this.mediaCapture = null;
            }

            if (mediaCapture != null)
            {
                mediaCapture.Failed -= OnMediaCaptureFailed;

                await mediaCapture.StopPreviewAsync();

                mediaCapture.Dispose();
            }
        }
        public static async Task<ContinuousAutoFocus> StartAsync(FocusControl control)
        {
            var autoFocus = new ContinuousAutoFocus(control);

            AutoFocusRange range;
            if (control.SupportedFocusRanges.Contains(AutoFocusRange.FullRange))
            {
                range = AutoFocusRange.FullRange;
            }
            else if (control.SupportedFocusRanges.Contains(AutoFocusRange.Normal))
            {
                range = AutoFocusRange.Normal;
            }
            else
            {
                // Auto-focus disabled
                return autoFocus;
            }

            FocusMode mode;
            if (control.SupportedFocusModes.Contains(FocusMode.Continuous))
            {
                mode = FocusMode.Continuous;
            }
            else if (control.SupportedFocusModes.Contains(FocusMode.Single))
            {
                mode = FocusMode.Single;
            }
            else
            {
                // Auto-focus disabled
                return autoFocus;
            }

            if (mode == FocusMode.Continuous)
            {
                // True continuous auto-focus
                var settings = new FocusSettings()
                {
                    AutoFocusRange = range,
                    Mode = mode,
                    WaitForFocus = false,
                    DisableDriverFallback = false
                };
                control.Configure(settings);
                await control.FocusAsync();
            }
            else
            {
                // Simulated continuous auto-focus
                var settings = new FocusSettings()
                {
                    AutoFocusRange = range,
                    Mode = mode,
                    WaitForFocus = true,
                    DisableDriverFallback = false
                };
                control.Configure(settings);

                var ignore = Task.Run(async () => { await autoFocus.DriveAutoFocusAsync(); });
            }

            return autoFocus;
        }
        private async Task InitializeCaptureAsync()
        {
            if (isMediaCaptureInitializing || (mediaCapture != null))
                return;
            isMediaCaptureInitializing = true;

            try
            {
                var settings = new MediaCaptureInitializationSettings
                {
                    VideoDeviceId = await GetBackOrDefaulCameraIdAsync(),
                    StreamingCaptureMode = StreamingCaptureMode.Video
                };

                var newMediaCapture = new MediaCapture();
                await newMediaCapture.InitializeAsync(settings);

                // Select the capture resolution closest to screen resolution
                var formats = newMediaCapture.VideoDeviceController.GetAvailableMediaStreamProperties(MediaStreamType.VideoPreview);
                var format = (VideoEncodingProperties)formats.OrderBy((item) =>
                {
                    var props = (VideoEncodingProperties)item;
                    return Math.Abs(props.Width - this.ActualHeight) + Math.Abs(props.Height - this.ActualWidth);
                }).First();

                Debug.WriteLine("{0} x {1}", format.Width, format.Height);

                await newMediaCapture.VideoDeviceController.SetMediaStreamPropertiesAsync(MediaStreamType.VideoPreview, format);

                // Disable flash control if supported
                if (newMediaCapture.VideoDeviceController.FlashControl.Supported)
                    newMediaCapture.VideoDeviceController.FlashControl.Enabled = false;

                // Prepare bitmap for reports
                bitmapWithBarcode = new WriteableBitmap((int)format.Width, (int)format.Height);

                // Make the preview full screen
                Preview.Width = this.ActualHeight;
                Preview.Height = this.ActualWidth;

                // Enable QR code detection
                var definition = new LumiaAnalyzerDefinition(ColorMode.Yuv420Sp, Math.Min(format.Width, 800), AnalyzeBitmap);
                await newMediaCapture.AddEffectAsync(MediaStreamType.VideoPreview, definition.ActivatableClassId, definition.Properties);

                // Start preview
                Preview.Source = newMediaCapture;
                await newMediaCapture.StartPreviewAsync();

                newMediaCapture.Failed += OnMediaCaptureFailed;

                autoFocus = await ContinuousAutoFocus.StartAsync(newMediaCapture.VideoDeviceController.FocusControl);

                mediaCapture = newMediaCapture;
            }
            catch (Exception e)
            {
                Debug.WriteLine("Failed to start the camera: {0}", e.Message);
            }

            isMediaCaptureInitializing = false;
        }